#54 - update function analysis to track return statements and code path completeness

Author: Stepami

src/Application/HydraScript.Application.CodeGeneration/Visitors/InstructionProvider.cs

@@ -139,7 +139,7 @@ public AddressedInstructions Visit(FunctionDeclaration visitable)
         }
 
         result.AddRange(visitable.Statements.Accept(This));
-        if (!visitable.HasReturnStatement())
+        if (!visitable.HasReturnStatement)
             result.Add(new Return());
 
         result.Add(new EndBlock(BlockType.Function, blockId: functionInfo.ToString()), functionInfo.End.Name);

src/Application/HydraScript.Application.StaticAnalysis/Visitors/DeclarationVisitor.cs

@@ -20,19 +20,22 @@ internal class DeclarationVisitor : VisitorNoReturnBase<IAbstractSyntaxTreeNode>
     private readonly ISymbolTableStorage _symbolTables;
     private readonly IAmbiguousInvocationStorage _ambiguousInvocations;
     private readonly IVisitor<TypeValue, Type> _typeBuilder;
+    private readonly IVisitor<FunctionDeclaration, ReturnAnalyzerResult> _returnAnalyzer;
 
     public DeclarationVisitor(
         IFunctionWithUndefinedReturnStorage functionStorage,
         IMethodStorage methodStorage,
         ISymbolTableStorage symbolTables,
         IAmbiguousInvocationStorage ambiguousInvocations,
-        IVisitor<TypeValue, Type> typeBuilder)
+        IVisitor<TypeValue, Type> typeBuilder,
+        IVisitor<FunctionDeclaration, ReturnAnalyzerResult> returnAnalyzer)
     {
         _functionStorage = functionStorage;
         _methodStorage = methodStorage;
         _symbolTables = symbolTables;
         _ambiguousInvocations = ambiguousInvocations;
         _typeBuilder = typeBuilder;
+        _returnAnalyzer = returnAnalyzer;
     }
 
     public override VisitUnit Visit(IAbstractSyntaxTreeNode visitable)
@@ -71,6 +74,9 @@ public VisitUnit Visit(LexicalDeclaration visitable)
 
     public VisitUnit Visit(FunctionDeclaration visitable)
     {
+        var returnAnalyzerResult = visitable.Accept(_returnAnalyzer);
+        visitable.ReturnStatements = returnAnalyzerResult.ReturnStatements;
+
         var parentTable = _symbolTables[visitable.Parent.Scope];
         var indexOfFirstDefaultArgument = visitable.Arguments.AsValueEnumerable()
             .Select((x, i) => new { Argument = x, Index = i })
@@ -88,7 +94,8 @@ public VisitUnit Visit(FunctionDeclaration visitable)
             visitable.Name,
             parameters,
             visitable.ReturnTypeValue.Accept(_typeBuilder),
-            visitable.IsEmpty);
+            visitable.IsEmpty,
+            returnAnalyzerResult.CodePathEndedWithReturn);
         if (functionSymbolId.Equals(parentTable.FindSymbol(functionSymbolId)?.Id))
             throw new OverloadAlreadyExists(visitable.Name, functionSymbolId);
 
@@ -108,7 +115,7 @@ public VisitUnit Visit(FunctionDeclaration visitable)
         Type undefined = "undefined";
         if (functionSymbol.Type.Equals(undefined))
         {
-            if (visitable.HasReturnStatement())
+            if (visitable.HasReturnStatement)
                 _functionStorage.Save(functionSymbol, visitable);
             else
                 functionSymbol.DefineReturnType("void");

src/Application/HydraScript.Application.StaticAnalysis/Visitors/SemanticChecker.cs

@@ -491,37 +491,26 @@ public Type Visit(FunctionDeclaration visitable)
         _functionStorage.RemoveIfPresent(symbol);
         visitable.Statements.Accept(This);
 
-        var returnStatements = visitable.ReturnStatements
-            .Select(x => new
-            {
-                Statement = x,
-                Type = x.Accept(This)
-            });
         Type undefined = "undefined";
-        if (symbol.Type.Equals(undefined))
+        HashSet<Type> returnTypes = [];
+        for (var i = 0; i < visitable.ReturnStatements.Count; i++)
         {
-            var returnStatementTypes = returnStatements
-                .GroupBy(x => x.Type)
-                .Select(x => x.Key)
-                .ToList();
-            if (returnStatementTypes.Count > 1)
+            var returnStatementType = visitable.ReturnStatements[i].Accept(This);
+            returnTypes.Add(returnStatementType);
+            if (returnTypes.Count > 1 && symbol.Type.Equals(undefined))
                 throw new CannotDefineType(visitable.Segment);
-            symbol.DefineReturnType(returnStatementTypes.ElementAtOrDefault(0) ?? "void");
-        }
-        else
-        {
-            var wrongReturn = returnStatements
-                .FirstOrDefault(x => !symbol.Type.Equals(x.Type));
-            if (wrongReturn is not null)
+            if (!symbol.Type.Equals(undefined) && !symbol.Type.Equals(returnStatementType))
                 throw new WrongReturnType(
-                    wrongReturn.Statement.Segment,
+                    visitable.ReturnStatements[i].Segment,
                     expected: symbol.Type,
-                    actual: wrongReturn.Type);
+                    actual: returnStatementType);
         }
 
+        if (symbol.Type.Equals(undefined))
+            symbol.DefineReturnType(returnTypes.Single());
+
         Type @void = "void";
-        var hasReturnStatement = visitable.HasReturnStatement();
-        if (!symbol.Type.Equals(@void) && !hasReturnStatement)
+        if (!symbol.Type.Equals(@void) && !symbol.AllCodePathsEndedWithReturn)
             throw new FunctionWithoutReturnStatement(visitable.Segment);
 
         if (symbol.Type is NullType)

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Declarations/AfterTypesAreLoaded/FunctionDeclaration.cs

@@ -18,6 +18,9 @@ public partial class FunctionDeclaration : AfterTypesAreLoadedDeclaration
     public BlockStatement Statements { get; }
     public bool IsEmpty => Statements.Count == 0;
 
+    public IReadOnlyList<ReturnStatement> ReturnStatements { get; set; } = [];
+    public bool HasReturnStatement => ReturnStatements.Count > 0;
+
     public string ComputedFunctionAddress { get; set; } = string.Empty;
 
     public FunctionDeclaration(
@@ -33,11 +36,6 @@ public FunctionDeclaration(
         Statements = blockStatement;
         Statements.Parent = this;
         Children = [Statements];
-
-        ReturnStatements = Statements
-            .GetAllNodes()
-            .OfType<ReturnStatement>()
-            .ToArray();
     }
 
     /// <summary>Стратегия "блока" - углубление скоупа</summary>
@@ -52,11 +50,6 @@ public override void InitScope(Scope? scope = null)
         ReturnTypeValue.Scope = Parent.Scope;
     }
 
-    public bool HasReturnStatement() =>
-        ReturnStatements.Count > 0;
-
-    public IReadOnlyCollection<ReturnStatement> ReturnStatements { get; }
-
     protected override string NodeRepresentation() =>
         ZString.Concat<string, char, string>("function", ' ', Name);
 }

src/Domain/HydraScript.Domain.IR/Impl/Symbols/FunctionSymbol.cs

@@ -8,7 +8,8 @@ public class FunctionSymbol(
     string name,
     IReadOnlyList<ISymbol> parameters,
     Type type,
-    bool isEmpty) : Symbol(name, type)
+    bool isEmpty,
+    bool allCodePathsEndedWithReturn) : Symbol(name, type)
 {
     private Type _returnType = type;
     /// <summary>Тип возврата функции</summary>
@@ -21,6 +22,7 @@ public class FunctionSymbol(
 
     public IReadOnlyList<ISymbol> Parameters { get; } = parameters;
     public bool IsEmpty { get; } = isEmpty;
+    public bool AllCodePathsEndedWithReturn { get; } = allCodePathsEndedWithReturn;
 
     public void DefineReturnType(Type returnType) =>
         _returnType = returnType;

tests/HydraScript.UnitTests/Application/FunctionWithUndefinedReturnStorageTests.cs

@@ -21,7 +21,8 @@ public void StorageIsEmptyAfterFlushTest()
             name: FunctionName,
             parameters: [],
             "undefined",
-            isEmpty: false);
+            isEmpty: false,
+            allCodePathsEndedWithReturn: false);
 
         var decl = new FunctionDeclaration(
             name: new IdentifierReference(FunctionName),
@@ -70,27 +71,31 @@ public void StorageIsCorrectOrderTest()
             name: "key2",
             parameters: [],
             "undefined",
-            isEmpty: false);
+            isEmpty: false,
+            allCodePathsEndedWithReturn: false);
 
         storage.Save(new FunctionSymbol(
             name: "key1",
             parameters: [],
             "undefined",
-            isEmpty: false), declaration: declarations[0]);
+            isEmpty: false,
+            allCodePathsEndedWithReturn: false), declaration: declarations[0]);
 
         storage.Save(removable, declaration: declarations[1]);
 
         storage.Save(new FunctionSymbol(
             name: "key3",
             parameters: [],
             "undefined",
-            isEmpty: false), declaration: declarations[2]);
+            isEmpty: false,
+            allCodePathsEndedWithReturn: false), declaration: declarations[2]);
 
         storage.Save(new FunctionSymbol(
             name: "key4",
             parameters: [],
             "undefined",
-            isEmpty: false), declaration: declarations[3]);
+            isEmpty: false,
+            allCodePathsEndedWithReturn: false), declaration: declarations[3]);
 
         storage.RemoveIfPresent(removable);