#207 - bug fix for with expr (#208)

* #207 - refactor InternalsVisibleTo management and update Directory.Build.props

* #207 - refactor ExpressionInstructionProvider and add unit tests for WithExpression handling

Author: Stepami

Directory.Build.props

@@ -1,4 +1,5 @@
 <Project>
+
     <PropertyGroup>
         <TargetFramework>net10.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>

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

@@ -80,9 +80,9 @@ public AddressedInstructions Visit(ObjectLiteral visitable)
         var result = new AddressedInstructions { createObject };
 
         var propInstructions = visitable.AsValueEnumerable()
-            .SelectMany(property => property.Accept(This));
-        foreach (var propInstruction in propInstructions)
-            result.Add(propInstruction);
+            .SelectMany(property => property.Accept(This))
+            .ToList();
+        result.AddRange(propInstructions);
 
         return result;
     }
@@ -162,19 +162,24 @@ public AddressedInstructions Visit(CastAsExpression visitable)
 
     public AddressedInstructions Visit(WithExpression visitable)
     {
-        if (visitable is { Expression: PrimaryExpression, ComputedCopiedProperties.Count: 0 })
-            return [];
-
         var objectId = visitable.ObjectLiteral.Id;
         var createObject = new CreateObject(objectId);
 
         var result = new AddressedInstructions { createObject };
 
+        if (visitable is { Expression: ObjectLiteral left, ObjectLiteral: {} right })
+        {
+            result.AddRange(left.AsValueEnumerable().Concat(right)
+                .SelectMany(property => property.Accept(This))
+                .ToList());
+            return result;
+        }
+
         var propInstructions = visitable.ObjectLiteral
             .AsValueEnumerable()
-            .SelectMany(property => property.Accept(This));
-        foreach (var propInstruction in propInstructions)
-            result.Add(propInstruction);
+            .SelectMany(property => property.Accept(This))
+            .ToList();
+        result.AddRange(propInstructions);
 
         if (visitable.ComputedCopiedProperties.Count is 0)
             return result;

src/Application/HydraScript.Application.StaticAnalysis/HydraScript.Application.StaticAnalysis.csproj

@@ -9,8 +9,4 @@
         <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
     </ItemGroup>
 
-    <ItemGroup>
-        <InternalsVisibleTo Include="HydraScript.UnitTests" />
-    </ItemGroup>
-
 </Project>

src/Directory.Build.props

@@ -0,0 +1,10 @@
+<Project>
+
+    <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
+
+    <ItemGroup>
+        <InternalsVisibleTo Include="HydraScript.UnitTests"/>
+        <InternalsVisibleTo Include="HydraScript.IntegrationTests"/>
+    </ItemGroup>
+
+</Project>

src/Domain/HydraScript.Domain.BackEnd/AddressedInstructions.cs

@@ -46,7 +46,7 @@ private void AddWithAddress(IExecutableInstruction instruction, IAddress newAddr
         last?.Value.Next = newAddress;
 
         var newNode = _addresses.AddLast(newAddress);
-        
+
         _addressToNode.Add(newAddress, newNode);
         _instructions.Add(newNode, instruction);
     }
@@ -59,11 +59,19 @@ public void AddRange(AddressedInstructions instructions)
         }
     }
 
+    public void AddRange(IReadOnlyList<IExecutableInstruction> instructions)
+    {
+        for (var i = 0; i < instructions.Count; i++)
+        {
+            Add(instructions[i]);
+        }
+    }
+
     public void Remove(IExecutableInstruction instruction)
     {
         var address = instruction.Address;
         var nodeToRemove = _addressToNode[address];
-        
+
         var prev = nodeToRemove.Previous;
         prev?.Value.Next = nodeToRemove.Next?.Value!;
 

src/Infrastructure/HydraScript.Infrastructure/HydraScript.Infrastructure.csproj

@@ -13,9 +13,4 @@
         <PackageReference Include="ZLogger" />
     </ItemGroup>
 
-    <ItemGroup>
-        <InternalsVisibleTo Include="HydraScript.UnitTests" />
-        <InternalsVisibleTo Include="HydraScript.IntegrationTests" />
-    </ItemGroup>
-
 </Project>

tests/Directory.Build.props

@@ -1,4 +1,5 @@
 <Project>
+
     <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
 
     <PropertyGroup>

tests/HydraScript.UnitTests/Application/ExpressionInstructionProviderTests.cs

@@ -0,0 +1,23 @@
+using HydraScript.Application.CodeGeneration.Impl;
+using HydraScript.Application.CodeGeneration.Visitors;
+using HydraScript.Domain.BackEnd;
+using HydraScript.Domain.FrontEnd.Parser;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions;
+
+namespace HydraScript.UnitTests.Application;
+
+public class ExpressionInstructionProviderTests(ITestOutputHelper testOutputHelper)
+{
+    private readonly ExpressionInstructionProvider _expressionInstructionProvider = new(new ValueDtoConverter());
+
+    [Theory, ClassData(typeof(WithExpressionData))]
+    public void Visit_WithExpression_ExpectedInstructions(
+        IAbstractSyntaxTree ast,
+        AddressedInstructions expected)
+    {
+        var withExpression = ast.Root.GetAllNodes().OfType<WithExpression>().Single();
+        var result = _expressionInstructionProvider.Visit(withExpression);
+        result.ToString().Should().Be(expected.ToString());
+        testOutputHelper.WriteLine(expected.ToString());
+    }
+}

tests/HydraScript.UnitTests/Application/WithExpressionData.cs

@@ -0,0 +1,58 @@
+using HydraScript.Domain.BackEnd;
+using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ComplexData.Create;
+using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ComplexData.Write;
+using HydraScript.Domain.BackEnd.Impl.Values;
+using HydraScript.Domain.FrontEnd.Parser;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Declarations;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.ComplexLiterals;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryExpressions;
+
+namespace HydraScript.UnitTests.Application;
+
+public sealed class WithExpressionData : TheoryData<IAbstractSyntaxTree, AddressedInstructions>
+{
+    public WithExpressionData()
+    {
+        // let obj = {x: 1;} with {}
+        Add(
+            new AbstractSyntaxTree(
+                new AssignmentExpression(
+                    new MemberExpression(new IdentifierReference("obj")),
+                    new WithExpression(
+                        new ObjectLiteral([
+                            new Property(
+                                new IdentifierReference("x"),
+                                new Literal(new TypeIdentValue(new IdentifierReference("number")), 1,
+                                    "(1, 15)-(1, 16)"))
+                        ]),
+                        new ObjectLiteral([])))),
+            [
+                new CreateObject("obj"),
+                new DotAssignment("obj", new Constant("x"), new Constant(1))
+            ]);
+
+        // let copyFrom = {x: 0;}
+        // let obj = copyFrom with {x: 1;}
+        Add(
+            new AbstractSyntaxTree(
+                new AssignmentExpression(
+                    new MemberExpression(new IdentifierReference("obj")),
+                    new WithExpression(
+                        new IdentifierReference("copyFrom"),
+                        new ObjectLiteral([
+                            new Property(
+                                new IdentifierReference("x"),
+                                new Literal(new TypeIdentValue(new IdentifierReference("number")), 1,
+                                    "(1, 15)-(1, 16)"))
+                        ]))
+                    {
+                        ComputedCopiedProperties = []
+                    })),
+            [
+                new CreateObject("obj"),
+                new DotAssignment("obj", new Constant("x"), new Constant(1))
+            ]);
+    }
+}