optimization simplifying refactoring:

Stepami · Stepami · commit 8888e6f55f4d · 2025-11-23T03:02:03.000+03:00
- func decl process
- return analysis
diff --git a/src/Application/HydraScript.Application.CodeGeneration/Visitors/InstructionProvider.cs b/src/Application/HydraScript.Application.CodeGeneration/Visitors/InstructionProvider.cs
@@ -132,10 +132,7 @@ public AddressedInstructions Visit(FunctionDeclaration visitable)
         for (var i = 0; i < visitable.Arguments.Count; i++)
         {
             var arg = visitable.Arguments[i];
-            if (arg is DefaultValueArgument @default)
-                result.Add(new PopParameter(arg.Name, @default.Info.Value));
-            else
-                result.Add(new PopParameter(arg.Name));
+            result.Add(new PopParameter(arg.Name, arg.Info.Value));
         }
 
         result.AddRange(visitable.Statements.Accept(This));
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Visitors/DeclarationVisitor.cs b/src/Application/HydraScript.Application.StaticAnalysis/Visitors/DeclarationVisitor.cs
@@ -7,7 +7,6 @@
 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;
 
@@ -79,16 +78,16 @@ public VisitUnit Visit(FunctionDeclaration visitable)
         visitable.AllCodePathsEndedWithReturn = returnAnalyzerResult.CodePathEndedWithReturn;
 
         var parentTable = _symbolTables[visitable.Parent.Scope];
-        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.AsValueEnumerable()
-            .Select(x =>
-                new VariableSymbol(
-                    x.Name,
-                    x.TypeValue.Accept(_typeBuilder))).ToList();
-        var functionSymbolId = new FunctionSymbolId(visitable.Name, parameters.Select(x => x.Type));
+        var parameters = new List<Type>();
+        for (var i = 0; i < visitable.Arguments.Count; i++)
+        {
+            parameters.Add(visitable.Arguments[i].TypeValue.Accept(_typeBuilder));
+            var arg = new VariableSymbol(visitable.Arguments[i].Name, parameters[i]);
+            arg.Initialize();
+            _symbolTables[visitable.Scope].AddSymbol(arg);
+        }
+        var functionSymbolId = new FunctionSymbolId(visitable.Name, parameters);
         _ambiguousInvocations.Clear(functionSymbolId);
         visitable.ComputedFunctionAddress = functionSymbolId.ToString();
         var functionSymbol = new FunctionSymbol(
@@ -99,18 +98,8 @@ public VisitUnit Visit(FunctionDeclaration visitable)
         if (functionSymbolId.Equals(parentTable.FindSymbol(functionSymbolId)?.Id))
             throw new OverloadAlreadyExists(visitable.Name, functionSymbolId);
 
-        for (var i = 0; i < parameters.Count; i++)
-        {
-            var arg = parameters[i];
-            arg.Initialize();
-            _symbolTables[visitable.Scope].AddSymbol(arg);
-        }
-
-        var isMethod =
-            parameters is [{ Type: ObjectType }, ..] &&
-            visitable.Arguments is [{ TypeValue: TypeIdentValue }, ..];
-        if (isMethod)
-            _methodStorage.BindMethod((parameters[0].Type as ObjectType)!, functionSymbol, functionSymbolId);
+        if (parameters is [ObjectType methodOwner, ..] && visitable.Arguments is [{ TypeValue: TypeIdentValue }, ..])
+            _methodStorage.BindMethod(methodOwner, functionSymbol, functionSymbolId);
 
         Type undefined = "undefined";
         if (functionSymbol.Type.Equals(undefined))
@@ -122,23 +111,22 @@ public VisitUnit Visit(FunctionDeclaration visitable)
         }
 
         parentTable.AddSymbol(functionSymbol);
-        for (var i = indexOfFirstDefaultArgument; i < visitable.Arguments.Count; i++)
+        for (var i = visitable.IndexOfFirstDefaultArgument; i < visitable.Arguments.Count; i++)
         {
-            if (i is -1) break;
-            if (visitable.Arguments[i] is not DefaultValueArgument)
+            if (visitable.Arguments[i].Info.Type is ValueDtoType.Name)
                 throw new NamedArgumentAfterDefaultValueArgument(
                     visitable.Segment,
                     function: visitable.Name,
                     visitable.Arguments[i]);
 
-            var overload = new FunctionSymbolId(visitable.Name, parameters[..i].Select(x => x.Type));
+            var overload = new FunctionSymbolId(visitable.Name, parameters[..i]);
             var existing = parentTable.FindSymbol(overload);
             var functionToAdd = existing is not null && existing < functionSymbol
                 ? existing
                 : functionSymbol;
             parentTable.AddSymbol(functionToAdd, overload);
-            if (isMethod)
-                _methodStorage.BindMethod((parameters[0].Type as ObjectType)!, functionToAdd, overload);
+            if (parameters is [ObjectType overloadOwner, ..] && visitable.Arguments is [{ TypeValue: TypeIdentValue }, ..])
+                _methodStorage.BindMethod(overloadOwner, functionToAdd, overload);
 
             if (existing is not null && !existing.Id.Equals(overload))
             {
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Visitors/ReturnAnalyzer.cs b/src/Application/HydraScript.Application.StaticAnalysis/Visitors/ReturnAnalyzer.cs
@@ -4,42 +4,53 @@
 
 namespace HydraScript.Application.StaticAnalysis.Visitors;
 
-internal class ReturnAnalyzer : VisitorBase<IAbstractSyntaxTreeNode, ReturnAnalyzerResult>,
+internal class ReturnAnalyzer : VisitorBase<IAbstractSyntaxTreeNode, bool>,
     IVisitor<FunctionDeclaration, ReturnAnalyzerResult>,
-    IVisitor<IfStatement, ReturnAnalyzerResult>,
-    IVisitor<ReturnStatement, ReturnAnalyzerResult>
+    IVisitor<IfStatement, bool>,
+    IVisitor<ReturnStatement, bool>
 {
+    private readonly List<ReturnStatement> _returnStatements = [];
+
     public ReturnAnalyzerResult Visit(FunctionDeclaration visitable)
     {
         IAbstractSyntaxTreeNode astNode = visitable;
-        return Visit(astNode);
+        var codePathEndedWithReturn= Visit(astNode);
+        var returnStatements = new List<ReturnStatement>(_returnStatements);
+        ReturnAnalyzerResult result = new(codePathEndedWithReturn, returnStatements);
+        _returnStatements.Clear();
+        return result;
     }
 
-    public override ReturnAnalyzerResult Visit(IAbstractSyntaxTreeNode visitable)
+    public override bool Visit(IAbstractSyntaxTreeNode visitable)
     {
-        var result = ReturnAnalyzerResult.AdditiveIdentity;
         for (var i = 0; i < visitable.Count; i++)
         {
             var visitableResult = visitable[i].Accept(This);
-            if (visitableResult.CodePathEndedWithReturn)
-                return visitableResult * result;
-            result += visitableResult;
+            if (visitableResult)
+                return true;
         }
 
-        return result;
+        return false;
     }
 
-    public ReturnAnalyzerResult Visit(IfStatement visitable)
+    public bool Visit(IfStatement visitable)
     {
         var thenReturns = visitable.Then.Accept(This);
 
         if (visitable.Else is null)
-            return thenReturns + ReturnAnalyzerResult.AdditiveIdentity;
+            return false;
         var elseReturns = visitable.Else.Accept(This);
 
-        return thenReturns + elseReturns;
+        return thenReturns && elseReturns;
+    }
+
+    public bool Visit(ReturnStatement visitable)
+    {
+        _returnStatements.Add(visitable);
+        return true;
     }
+}
 
-    public ReturnAnalyzerResult Visit(ReturnStatement visitable) =>
-        new(CodePathEndedWithReturn: true, ReturnStatements: [visitable]);
-}
+public sealed record ReturnAnalyzerResult(
+    bool CodePathEndedWithReturn,
+    IReadOnlyList<ReturnStatement> ReturnStatements);
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Visitors/ReturnAnalyzerResult.cs b/src/Application/HydraScript.Application.StaticAnalysis/Visitors/ReturnAnalyzerResult.cs
diff --git a/src/Application/HydraScript.Application.StaticAnalysis/Visitors/SemanticChecker.cs b/src/Application/HydraScript.Application.StaticAnalysis/Visitors/SemanticChecker.cs
@@ -466,9 +466,9 @@ public Type Visit(CallExpression visitable)
             .Zip(parameters).Zip(functionSymbol.Parameters.AsValueEnumerable().Skip(methodCall ? 1 : 0))
             .ToList().ForEach(pair =>
             {
-                var ((expr, actualType), expected) = pair;
-                if (!actualType.Equals(expected.Type))
-                    throw new WrongTypeOfArgument(expr.Segment, expected.Type, actualType);
+                var ((expr, actualType), expectedType) = pair;
+                if (!actualType.Equals(expectedType))
+                    throw new WrongTypeOfArgument(expr.Segment, expectedType, actualType);
             });
 
         Type undefined = "undefined";
@@ -486,7 +486,7 @@ public Type Visit(CallExpression visitable)
 
     public Type Visit(FunctionDeclaration visitable)
     {
-        var parameters = visitable.Arguments.Select(x => x.TypeValue.Accept(_typeBuilder));
+        var parameters = visitable.Arguments.Select(x => x.TypeValue.Accept(_typeBuilder)).ToList();
         var symbol = _symbolTables[visitable.Scope].FindSymbol(new FunctionSymbolId(visitable.Name, parameters))!;
         _functionStorage.RemoveIfPresent(symbol);
         visitable.Statements.Accept(This);
diff --git a/src/Domain/HydraScript.Domain.BackEnd/Impl/Instructions/PopParameter.cs b/src/Domain/HydraScript.Domain.BackEnd/Impl/Instructions/PopParameter.cs
@@ -1,6 +1,6 @@
 namespace HydraScript.Domain.BackEnd.Impl.Instructions;
 
-public class PopParameter(string parameter, object? defaultValue = null) : Instruction
+public class PopParameter(string parameter, object? defaultValue) : Instruction
 {
     public override IAddress? Execute(IExecuteParams executeParams)
     {
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Declarations/AfterTypesAreLoaded/FunctionDeclaration.cs b/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Declarations/AfterTypesAreLoaded/FunctionDeclaration.cs
@@ -14,6 +14,7 @@ public partial class FunctionDeclaration : AfterTypesAreLoadedDeclaration
     public IdentifierReference Name { get; }
     public TypeValue ReturnTypeValue { get; }
     public IReadOnlyList<IFunctionArgument> Arguments => _arguments;
+    public int IndexOfFirstDefaultArgument { get; }
 
     public BlockStatement Statements { get; }
     public bool IsEmpty => Statements.Count == 0;
@@ -28,11 +29,13 @@ public FunctionDeclaration(
         IdentifierReference name,
         TypeValue returnTypeValue,
         List<IFunctionArgument> arguments,
-        BlockStatement blockStatement)
+        BlockStatement blockStatement,
+        int indexOfFirstDefaultArgument)
     {
         Name = name;
         ReturnTypeValue = returnTypeValue;
         _arguments = arguments;
+        IndexOfFirstDefaultArgument = indexOfFirstDefaultArgument;
 
         Statements = blockStatement;
         Statements.Parent = this;
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Declarations/AfterTypesAreLoaded/IFunctionArgument.cs b/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Declarations/AfterTypesAreLoaded/IFunctionArgument.cs
@@ -7,6 +7,8 @@ public interface IFunctionArgument
     public string Name { get; }
 
     public TypeValue TypeValue { get; }
+
+    public ValueDto Info { get; }
 }
 
 public record NamedArgument(
@@ -15,6 +17,8 @@ public record NamedArgument(
 {
     public override string ToString() =>
         $"{Name}: {TypeValue}";
+
+    public ValueDto Info { get; } = ValueDto.NameDto(Name);
 }
 
 public record DefaultValueArgument : IFunctionArgument
diff --git a/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/TopDownParser.cs b/src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/TopDownParser.cs
@@ -340,6 +340,7 @@ private FunctionDeclaration FunctionDeclaration()
 
         Expect("LeftParen");
         var args = new List<IFunctionArgument>();
+        var indexOfFirstDefaultArgument = int.MaxValue;
         while (CurrentIs("Ident"))
         {
             var arg = Expect("Ident").Value;
@@ -353,6 +354,9 @@ private FunctionDeclaration FunctionDeclaration()
             {
                 Expect("Assign");
                 var value = Literal();
+                indexOfFirstDefaultArgument = args.Count < indexOfFirstDefaultArgument
+                    ? args.Count
+                    : indexOfFirstDefaultArgument;
                 args.Add(new DefaultValueArgument(arg, value));
             }
 
@@ -373,7 +377,7 @@ private FunctionDeclaration FunctionDeclaration()
         }
 
         var name = new IdentifierReference(ident.Value) { Segment = ident.Segment };
-        return new FunctionDeclaration(name, returnType, args, BlockStatement())
+        return new FunctionDeclaration(name, returnType, args, BlockStatement(), indexOfFirstDefaultArgument)
             { Segment = ident.Segment };
     }
 
diff --git a/src/Domain/HydraScript.Domain.IR/Impl/Symbols/FunctionSymbol.cs b/src/Domain/HydraScript.Domain.IR/Impl/Symbols/FunctionSymbol.cs
@@ -6,7 +6,7 @@ namespace HydraScript.Domain.IR.Impl.Symbols;
 
 public class FunctionSymbol(
     string name,
-    IReadOnlyList<ISymbol> parameters,
+    IReadOnlyList<Type> parameters,
     Type type,
     bool isEmpty) : Symbol(name, type)
 {
@@ -17,9 +17,9 @@ public class FunctionSymbol(
     /// <summary>
     /// Перегрузка функции
     /// </summary>
-    public override FunctionSymbolId Id { get; } = new(name, parameters.Select(x => x.Type));
+    public override FunctionSymbolId Id { get; } = new(name, parameters);
 
-    public IReadOnlyList<ISymbol> Parameters { get; } = parameters;
+    public IReadOnlyList<Type> Parameters { get; } = parameters;
     public bool IsEmpty { get; } = isEmpty;
 
     public void DefineReturnType(Type returnType) =>
diff --git a/src/Domain/HydraScript.Domain.IR/Impl/Symbols/Ids/FunctionSymbolId.cs b/src/Domain/HydraScript.Domain.IR/Impl/Symbols/Ids/FunctionSymbolId.cs
@@ -4,7 +4,7 @@ namespace HydraScript.Domain.IR.Impl.Symbols.Ids;
 
 public class FunctionSymbolId(
     string name,
-    IEnumerable<Type> parameters) : SymbolId<FunctionSymbol>
+    IReadOnlyList<Type> parameters) : SymbolId<FunctionSymbol>
 {
     protected override string Value { get; } =
         $"function {name}({ZString.Join(", ", parameters)})";
diff --git a/src/Domain/HydraScript.Domain.IR/Impl/Symbols/Ids/TypeSymbolId.cs b/src/Domain/HydraScript.Domain.IR/Impl/Symbols/Ids/TypeSymbolId.cs
@@ -1,6 +1,8 @@
+using Cysharp.Text;
+
 namespace HydraScript.Domain.IR.Impl.Symbols.Ids;
 
 public class TypeSymbolId(string name) : SymbolId<TypeSymbol>
 {
-    protected override string Value { get; } = $"type {name}";
+    protected override string Value { get; } = ZString.Concat("type", ' ', name);
 }
diff --git a/tests/HydraScript.UnitTests/Application/FunctionWithUndefinedReturnStorageTests.cs b/tests/HydraScript.UnitTests/Application/FunctionWithUndefinedReturnStorageTests.cs
@@ -27,7 +27,8 @@ public void StorageIsEmptyAfterFlushTest()
             name: new IdentifierReference(FunctionName),
             returnTypeValue: Substitute.For<TypeValue>(),
             arguments: [],
-            new BlockStatement([]));
+            new BlockStatement([]),
+            indexOfFirstDefaultArgument: int.MaxValue);
 
         storage.Save(symbol, decl);
 
@@ -44,26 +45,30 @@ public void StorageIsCorrectOrderTest()
                 name: new IdentifierReference(FunctionName + "1"),
                 returnTypeValue: Substitute.For<TypeValue>(),
                 arguments: [],
-                new BlockStatement([])),
+                new BlockStatement([]),
+                indexOfFirstDefaultArgument: int.MaxValue),
 
             new(
                 name: new IdentifierReference(FunctionName + "2"),
                 returnTypeValue: Substitute.For<TypeValue>(),
                 arguments: [],
-                new BlockStatement([])),
+                new BlockStatement([]),
+                indexOfFirstDefaultArgument: int.MaxValue),
 
             new(
                 name: new IdentifierReference(FunctionName + "3"),
                 returnTypeValue: Substitute.For<TypeValue>(),
                 arguments: [],
-                new BlockStatement([])),
+                new BlockStatement([]),
+                indexOfFirstDefaultArgument: int.MaxValue),
 
             new(
                 name: new IdentifierReference(FunctionName + "4"),
                 returnTypeValue: Substitute.For<TypeValue>(),
                 arguments: [],
-                new BlockStatement([]))];
-        
+                new BlockStatement([]),
+                indexOfFirstDefaultArgument: int.MaxValue)];
+
         IFunctionWithUndefinedReturnStorage storage = new FunctionWithUndefinedReturnStorage();
 
         var removable = new FunctionSymbol(
diff --git a/tests/HydraScript.UnitTests/Application/ReturnAnalyzerTests.cs b/tests/HydraScript.UnitTests/Application/ReturnAnalyzerTests.cs
@@ -29,7 +29,8 @@ public void Visit_FunctionWithMissingReturn_CodePathEndedWithReturnIsFalse()
                     new IdentifierReference("b"),
                     new ReturnStatement(
                         new Literal(new TypeIdentValue(new IdentifierReference("number")), 1, "segment")))
-            ]));
+            ]),
+            indexOfFirstDefaultArgument: int.MaxValue);
 
         // Act
         var result = new ReturnAnalyzer().Visit(functionDeclaration);
diff --git a/tests/HydraScript.UnitTests/Domain/BackEnd/InstructionsData.cs b/tests/HydraScript.UnitTests/Domain/BackEnd/InstructionsData.cs
@@ -98,7 +98,7 @@ public IEnumerator<object[]> GetEnumerator()
         ];
         yield return
         [
-            new PopParameter("param"),
+            new PopParameter("param", defaultValue: null),
             "PopParameter param"
         ];
         yield return
diff --git a/tests/HydraScript.UnitTests/Domain/BackEnd/VirtualMachineTests.cs b/tests/HydraScript.UnitTests/Domain/BackEnd/VirtualMachineTests.cs
diff --git a/tests/HydraScript.UnitTests/Domain/FrontEnd/AstNodeTests.cs b/tests/HydraScript.UnitTests/Domain/FrontEnd/AstNodeTests.cs

Original file line number	Diff line number	Diff line change
`@@ -132,10 +132,7 @@ public AddressedInstructions Visit(FunctionDeclaration visitable)`
`132`	`132`	`for (var i = 0; i < visitable.Arguments.Count; i++)`
`133`	`133`	`{`
`134`	`134`	`var arg = visitable.Arguments[i];`
`135`		`- if (arg is DefaultValueArgument @default)`
`136`		`- result.Add(new PopParameter(arg.Name, @default.Info.Value));`
`137`		`- else`
`138`		`- result.Add(new PopParameter(arg.Name));`
	`135`	`+ result.Add(new PopParameter(arg.Name, arg.Info.Value));`
`139`	`136`	`}`
`140`	`137`
`141`	`138`	`result.AddRange(visitable.Statements.Accept(This));`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`namespace HydraScript.Domain.BackEnd.Impl.Instructions;`
`2`	`2`
`3`		`-public class PopParameter(string parameter, object? defaultValue = null) : Instruction`
	`3`	`+public class PopParameter(string parameter, object? defaultValue) : Instruction`
`4`	`4`	`{`
`5`	`5`	`public override IAddress? Execute(IExecuteParams executeParams)`
`6`	`6`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@ public interface IFunctionArgument`
`7`	`7`	`public string Name { get; }`
`8`	`8`
`9`	`9`	`public TypeValue TypeValue { get; }`
	`10`	`+`
	`11`	`+ public ValueDto Info { get; }`
`10`	`12`	`}`
`11`	`13`
`12`	`14`	`public record NamedArgument(`
`@@ -15,6 +17,8 @@ public record NamedArgument(`
`15`	`17`	`{`
`16`	`18`	`public override string ToString() =>`
`17`	`19`	`$"{Name}: {TypeValue}";`
	`20`	`+`
	`21`	`+ public ValueDto Info { get; } = ValueDto.NameDto(Name);`
`18`	`22`	`}`
`19`	`23`
`20`	`24`	`public record DefaultValueArgument : IFunctionArgument`
Original file line number	Diff line number	Diff line change
`@@ -340,6 +340,7 @@ private FunctionDeclaration FunctionDeclaration()`
`340`	`340`
`341`	`341`	`Expect("LeftParen");`
`342`	`342`	`var args = new List<IFunctionArgument>();`
	`343`	`+ var indexOfFirstDefaultArgument = int.MaxValue;`
`343`	`344`	`while (CurrentIs("Ident"))`
`344`	`345`	`{`
`345`	`346`	`var arg = Expect("Ident").Value;`
`@@ -353,6 +354,9 @@ private FunctionDeclaration FunctionDeclaration()`
`353`	`354`	`{`
`354`	`355`	`Expect("Assign");`
`355`	`356`	`var value = Literal();`
	`357`	`+ indexOfFirstDefaultArgument = args.Count < indexOfFirstDefaultArgument`
	`358`	`+ ? args.Count`
	`359`	`+ : indexOfFirstDefaultArgument;`
`356`	`360`	`args.Add(new DefaultValueArgument(arg, value));`
`357`	`361`	`}`
`358`	`362`
`@@ -373,7 +377,7 @@ private FunctionDeclaration FunctionDeclaration()`
`373`	`377`	`}`
`374`	`378`
`375`	`379`	`var name = new IdentifierReference(ident.Value) { Segment = ident.Segment };`
`376`		`- return new FunctionDeclaration(name, returnType, args, BlockStatement())`
	`380`	`+ return new FunctionDeclaration(name, returnType, args, BlockStatement(), indexOfFirstDefaultArgument)`
`377`	`381`	`{ Segment = ident.Segment };`
`378`	`382`	`}`
`379`	`383`