#167 - доработка статического анализа на проверку неоднозначных вызовов

Author: Stepami

src/Application/HydraScript.Application.StaticAnalysis/Exceptions/AmbiguousInvocation.cs

@@ -0,0 +1,12 @@
+using System.Diagnostics.CodeAnalysis;
+using HydraScript.Domain.IR.Impl.Symbols.Ids;
+
+namespace HydraScript.Application.StaticAnalysis.Exceptions;
+
+[ExcludeFromCodeCoverage]
+public class AmbiguousInvocation(
+    string segment,
+    IReadOnlyCollection<FunctionSymbolId> candidates) :
+    SemanticException(
+        segment,
+        $"Candidates are:\n{string.Join('\n', candidates)}");

src/Application/HydraScript.Application.StaticAnalysis/IAmbiguousInvocationStorage.cs

@@ -0,0 +1,10 @@
+using HydraScript.Domain.IR.Impl.Symbols.Ids;
+
+namespace HydraScript.Application.StaticAnalysis;
+
+public interface IAmbiguousInvocationStorage
+{
+    void WriteCandidate(FunctionSymbolId invocation, FunctionSymbolId candidate);
+
+    void CheckCandidatesAndThrow(string segment, FunctionSymbolId invocation);
+}

src/Application/HydraScript.Application.StaticAnalysis/Impl/AmbiguousInvocationStorage.cs

@@ -0,0 +1,23 @@
+using HydraScript.Application.StaticAnalysis.Exceptions;
+using HydraScript.Domain.IR.Impl.Symbols.Ids;
+
+namespace HydraScript.Application.StaticAnalysis.Impl;
+
+internal class AmbiguousInvocationStorage : IAmbiguousInvocationStorage
+{
+    private readonly Dictionary<FunctionSymbolId, HashSet<FunctionSymbolId>> _invocations = [];
+
+    public void WriteCandidate(FunctionSymbolId invocation, FunctionSymbolId candidate)
+    {
+        if (!_invocations.ContainsKey(invocation))
+            _invocations[invocation] = [];
+        _invocations[invocation].Add(candidate);
+    }
+
+    public void CheckCandidatesAndThrow(string segment, FunctionSymbolId invocation)
+    {
+        var candidates = _invocations.GetValueOrDefault(invocation, []);
+        if (candidates.Count > 0)
+            throw new AmbiguousInvocation(segment, candidates);
+    }
+}

src/Application/HydraScript.Application.StaticAnalysis/ServiceCollectionExtensions.cs

@@ -21,6 +21,8 @@ public static IServiceCollection AddStaticAnalysis(this IServiceCollection servi
         services.AddSingleton<IJavaScriptTypesProvider, JavaScriptTypesProvider>();
         services.AddSingleton<IDefaultValueForTypeCalculator, DefaultValueForTypeCalculator>();
 
+        services.AddSingleton<IAmbiguousInvocationStorage, AmbiguousInvocationStorage>();
+
         services.AddSingleton<IVisitor<TypeValue, Type>, TypeBuilder>();
 
         services.AddSingleton<IVisitor<IAbstractSyntaxTreeNode>, SymbolTableInitializer>();

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

@@ -17,17 +17,20 @@ internal class DeclarationVisitor : VisitorNoReturnBase<IAbstractSyntaxTreeNode>
     private readonly IFunctionWithUndefinedReturnStorage _functionStorage;
     private readonly IMethodStorage _methodStorage;
     private readonly ISymbolTableStorage _symbolTables;
+    private readonly IAmbiguousInvocationStorage _ambiguousInvocations;
     private readonly IVisitor<TypeValue, Type> _typeBuilder;
 
     public DeclarationVisitor(
         IFunctionWithUndefinedReturnStorage functionStorage,
         IMethodStorage methodStorage,
         ISymbolTableStorage symbolTables,
+        IAmbiguousInvocationStorage ambiguousInvocations,
         IVisitor<TypeValue, Type> typeBuilder)
     {
         _functionStorage = functionStorage;
         _methodStorage = methodStorage;
         _symbolTables = symbolTables;
+        _ambiguousInvocations = ambiguousInvocations;
         _typeBuilder = typeBuilder;
     }
 
@@ -128,6 +131,12 @@ public VisitUnit Visit(FunctionDeclaration visitable)
             {
                 parentTable.AddSymbol(existing, overload);
             }
+
+            if (existing is not null && !existing.Id.Equals(overload))
+            {
+                _ambiguousInvocations.WriteCandidate(overload, existing.Id);
+                _ambiguousInvocations.WriteCandidate(overload, functionSymbolId);
+            }
         }
 
         return visitable.Statements.Accept(This);

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

@@ -46,6 +46,7 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     private readonly IMethodStorage _methodStorage;
     private readonly ISymbolTableStorage _symbolTables;
     private readonly IComputedTypesStorage _computedTypes;
+    private readonly IAmbiguousInvocationStorage _ambiguousInvocations;
     private readonly IVisitor<TypeValue, Type> _typeBuilder;
 
     public SemanticChecker(
@@ -54,13 +55,15 @@ public SemanticChecker(
         IMethodStorage methodStorage,
         ISymbolTableStorage symbolTables,
         IComputedTypesStorage computedTypes,
+        IAmbiguousInvocationStorage ambiguousInvocations,
         IVisitor<TypeValue, Type> typeBuilder)
     {
         _calculator = calculator;
         _functionStorage = functionStorage;
         _methodStorage = methodStorage;
         _symbolTables = symbolTables;
         _computedTypes = computedTypes;
+        _ambiguousInvocations = ambiguousInvocations;
         _typeBuilder = typeBuilder;
     }
 
@@ -411,13 +414,15 @@ public Type Visit(CallExpression visitable)
             var objectType = (ObjectType)visitable.Member.Accept(This);
             var availableMethods = _methodStorage.GetAvailableMethods(objectType);
             var methodKey = new FunctionSymbolId(objectType.LastAccessedMethodName, [objectType, ..parameters]);
+            _ambiguousInvocations.CheckCandidatesAndThrow(visitable.Segment, methodKey);
             functionSymbol =
                 availableMethods.GetValueOrDefault(methodKey)
                 ?? throw new UnknownFunctionOverload(visitable.Id, methodKey);
         }
         else
         {
             var functionKey = new FunctionSymbolId(visitable.Id, parameters);
+            _ambiguousInvocations.CheckCandidatesAndThrow(visitable.Segment, functionKey);
             functionSymbol =
                 _symbolTables[visitable.Scope].FindSymbol(functionKey)
                 ?? throw new UnknownFunctionOverload(visitable.Id, functionKey);

tests/HydraScript.IntegrationTests/ErrorPrograms/DefaultParameterTests.cs

@@ -12,6 +12,30 @@ public void DefaultParameter_PlacedBeforeNamed_HydraScriptError()
         var code = runner.Invoke();
         code.Should().Be(Executor.ExitCodes.HydraScriptError);
         fixture.LogMessages.Should()
-            .Contain(x => x.Contains("The argument b: boolean of function func is placed after default value argument"));
+            .Contain(x =>
+                x.Contains("The argument b: boolean of function func is placed after default value argument"));
+    }
+
+    [Fact]
+    public void DefaultParameter_AmbiguousInvocation_HydraScriptError()
+    {
+        const string script =
+                """
+                function f(a = 0){}
+                function f(a = 0, b = 1) {}
+                function f(a = 0, b = 1, c = 2) {}
+
+                f()
+                """
+            ;
+        using var runner = fixture.GetRunner(new TestHostFixture.Options(InMemoryScript: script));
+        var code = runner.Invoke();
+        code.Should().Be(Executor.ExitCodes.HydraScriptError);
+        const string expectedMessage =
+            "Candidates are:\n" +
+            "function f(number)\n" +
+            "function f(number, number)\n" +
+            "function f(number, number, number)";
+        fixture.LogMessages.Should().Contain(x => x.Contains(expectedMessage));
     }
 }