Bug/method def param (#188)

* #187 - added test

* #187 - fix: bind new overload to object

* fix

Author: Stepami

src/Application/HydraScript.Application.StaticAnalysis/IMethodStorage.cs

@@ -6,7 +6,7 @@ namespace HydraScript.Application.StaticAnalysis;
 
 public interface IMethodStorage
 {
-    public void BindMethod(ObjectType objectType, FunctionSymbol method);
+    public void BindMethod(ObjectType objectType, FunctionSymbol method, FunctionSymbolId overload);
 
     public IReadOnlyDictionary<FunctionSymbolId, FunctionSymbol> GetAvailableMethods(ObjectType objectType);
 

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

@@ -8,12 +8,12 @@ internal class MethodStorage : IMethodStorage
 {
     private readonly Dictionary<ObjectType, Dictionary<FunctionSymbolId, FunctionSymbol>> _bindings = [];
 
-    public void BindMethod(ObjectType objectType, FunctionSymbol method)
+    public void BindMethod(ObjectType objectType, FunctionSymbol method, FunctionSymbolId overload)
     {
-        objectType.AddMethod(method.Id);
+        objectType.AddMethod(overload);
         if (!_bindings.ContainsKey(objectType))
             _bindings[objectType] = new Dictionary<FunctionSymbolId, FunctionSymbol>();
-        _bindings[objectType][method.Id] = method;
+        _bindings[objectType][overload] = method;
     }
 
     public IReadOnlyDictionary<FunctionSymbolId, FunctionSymbol> GetAvailableMethods(ObjectType objectType) =>

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

@@ -99,11 +99,11 @@ public VisitUnit Visit(FunctionDeclaration visitable)
             _symbolTables[visitable.Scope].AddSymbol(arg);
         }
 
-        if (parameters is [{ Type: ObjectType objectType }, ..] &&
-            visitable.Arguments is [{ TypeValue: TypeIdentValue }, ..])
-        {
-            _methodStorage.BindMethod(objectType, functionSymbol);
-        }
+        var isMethod =
+            parameters is [{ Type: ObjectType }, ..] &&
+            visitable.Arguments is [{ TypeValue: TypeIdentValue }, ..];
+        if (isMethod)
+            _methodStorage.BindMethod((parameters[0].Type as ObjectType)!, functionSymbol, functionSymbolId);
 
         Type undefined = "undefined";
         if (functionSymbol.Type.Equals(undefined))
@@ -126,11 +126,12 @@ public VisitUnit Visit(FunctionDeclaration visitable)
 
             var overload = new FunctionSymbolId(visitable.Name, parameters[..i].Select(x => x.Type));
             var existing = parentTable.FindSymbol(overload);
-            parentTable.AddSymbol(functionSymbol, overload);
-            if (existing is not null && existing < functionSymbol)
-            {
-                parentTable.AddSymbol(existing, 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 (existing is not null && !existing.Id.Equals(overload))
             {

src/Domain/HydraScript.Domain.IR/ISymbol.cs

@@ -3,6 +3,5 @@ namespace HydraScript.Domain.IR;
 public interface ISymbol
 {
     public ISymbolId<ISymbol> Id { get; }
-    public string Name { get; }
     public Type Type { get; }
 }

tests/HydraScript.IntegrationTests/HydraScript.IntegrationTests.csproj

@@ -29,6 +29,9 @@
         <None Update="Samples\ceil.js">
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </None>
+        <None Update="Samples\counter.js">
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+        </None>
         <None Update="Samples\cycled.js">
             <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </None>

tests/HydraScript.IntegrationTests/Samples/counter.js

@@ -0,0 +1,16 @@
+type Counter = {
+    state:number;
+}
+
+function next(counter: Counter, step = 1){
+    counter.state = counter.state + step
+    return counter.state
+}
+
+function newCounter(start: number):Counter{
+    return { state: start; }
+}
+
+let counter = newCounter(4)
+>>>counter.next()
+>>>counter.next(2)