#16 - with выражение +semver:feature (#194)

* #16 - add xmldoc grammar rule summaries to TopDownParser

* #16 - add 'with' keyword to TokenTypes

* #16 - update grammar to include 'with' expressions

* #16 - implement 'with' expression parsing and AST node

* #16 - add IsSubsetOf method to ObjectType with comprehensive tests

* #16 - update static analysis in SemanticChecker to support 'with' expression and refine visitor return types

* #16 - add CalculateDifference method to ObjectType and integrate with SemanticChecker; update unit tests to include CalculateDifference and refactor IsSubsetOf tests

* #16 - refactor ComplexLiteral hierarchy: make Id property abstract and implement in derived classes

* #16 - add codegen visitor implementation for 'with' expressions and remove dead code in DotRead

* #16 - add integration test samples for 'with' expressions

* #16 - add contents:write perm to release workflow

Author: Stepami

.github/workflows/release.yml

@@ -5,6 +5,9 @@ on:
     branches:
       - 'release'
 
+permissions:
+  contents: write
+
 jobs:
   create-release:
     name: Create release

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

@@ -24,6 +24,7 @@ internal class ExpressionInstructionProvider : VisitorBase<IAbstractSyntaxTreeNo
     IVisitor<UnaryExpression, AddressedInstructions>,
     IVisitor<BinaryExpression, AddressedInstructions>,
     IVisitor<CastAsExpression, AddressedInstructions>,
+    IVisitor<WithExpression, AddressedInstructions>,
     IVisitor<ConditionalExpression, AddressedInstructions>,
     IVisitor<AssignmentExpression, AddressedInstructions>,
     IVisitor<MemberExpression, AddressedInstructions>,
@@ -36,6 +37,8 @@ internal class ExpressionInstructionProvider : VisitorBase<IAbstractSyntaxTreeNo
     public ExpressionInstructionProvider(IValueDtoConverter valueDtoConverter) =>
         _valueDtoConverter = valueDtoConverter;
 
+    public override AddressedInstructions Visit(IAbstractSyntaxTreeNode visitable) => [];
+
     public AddressedInstructions Visit(PrimaryExpression visitable) =>
         [new Simple(_valueDtoConverter.Convert(visitable.ToValueDto()))];
 
@@ -76,9 +79,8 @@ public AddressedInstructions Visit(ObjectLiteral visitable)
 
         var result = new AddressedInstructions { createObject };
 
-        var propInstructions =
-            visitable.Properties.AsValueEnumerable()
-                .SelectMany(property => property.Accept(This));
+        var propInstructions = visitable.AsValueEnumerable()
+            .SelectMany(property => property.Accept(This));
         foreach (var propInstruction in propInstructions)
             result.Add(propInstruction);
 
@@ -158,6 +160,42 @@ public AddressedInstructions Visit(CastAsExpression visitable)
         return result;
     }
 
+    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 };
+
+        var propInstructions = visitable.ObjectLiteral
+            .AsValueEnumerable()
+            .SelectMany(property => property.Accept(This));
+        foreach (var propInstruction in propInstructions)
+            result.Add(propInstruction);
+
+        if (visitable.ComputedCopiedProperties.Count is 0)
+            return result;
+
+        result.AddRange(visitable.Expression is PrimaryExpression ? [] : visitable.Expression.Accept(This));
+
+        var copyFrom = visitable.Expression is PrimaryExpression primary
+            ? (Name)_valueDtoConverter.Convert(primary.ToValueDto())
+            : new Name(result.OfType<Simple>().Last().Left!);
+
+        for (var i = 0; i < visitable.ComputedCopiedProperties.Count; i++)
+        {
+            var property = new Constant(visitable.ComputedCopiedProperties[i]);
+            result.Add(new DotRead(copyFrom, property));
+            var read = result[result.End].Address.Name;
+            result.Add(new DotAssignment(objectId, property, new Name(read)));
+        }
+
+        return result;
+    }
+
     public AddressedInstructions Visit(ConditionalExpression visitable)
     {
         var blockId = $"cond_{visitable.GetHashCode()}";

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

@@ -26,8 +26,8 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     IVisitor<IdentifierReference, Type>,
     IVisitor<Literal, Type>,
     IVisitor<ImplicitLiteral, Type>,
-    IVisitor<ArrayLiteral, Type>,
-    IVisitor<ObjectLiteral, Type>,
+    IVisitor<ArrayLiteral, ArrayType>,
+    IVisitor<ObjectLiteral, ObjectType>,
     IVisitor<ConditionalExpression, Type>,
     IVisitor<BinaryExpression, Type>,
     IVisitor<UnaryExpression, Type>,
@@ -37,6 +37,7 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     IVisitor<IndexAccess, Type>,
     IVisitor<DotAccess, Type>,
     IVisitor<CastAsExpression, Type>,
+    IVisitor<WithExpression, ObjectType>,
     IVisitor<CallExpression, Type>,
     IVisitor<FunctionDeclaration, Type>,
     IVisitor<BlockStatement, Type>,
@@ -163,7 +164,7 @@ public Type Visit(ImplicitLiteral visitable)
         return type;
     }
 
-    public Type Visit(ArrayLiteral visitable)
+    public ArrayType Visit(ArrayLiteral visitable)
     {
         if (visitable.Expressions.Count == 0)
             return new ArrayType(new Any());
@@ -175,7 +176,7 @@ public Type Visit(ArrayLiteral visitable)
         throw new WrongArrayLiteralDeclaration(visitable.Segment, type);
     }
 
-    public Type Visit(ObjectLiteral visitable)
+    public ObjectType Visit(ObjectLiteral visitable)
     {
         var properties = visitable.Properties.AsValueEnumerable().Select(prop =>
         {
@@ -398,6 +399,27 @@ public Type Visit(DotAccess visitable)
         return visitable.HasNext() ? visitable.Next?.Accept(This) ?? "undefined" : fieldType;
     }
 
+    public ObjectType Visit(WithExpression visitable)
+    {
+        var exprType = visitable.Expression.Accept(This);
+
+        if (exprType is not ObjectType supersetObjectType)
+            throw new UnsupportedOperation(visitable.Segment, exprType, "with");
+
+        IVisitor<ObjectLiteral, ObjectType> objectLiteralVisitor = this;
+        var subsetObjectType = visitable.ObjectLiteral.Accept(objectLiteralVisitor);
+
+        if (!supersetObjectType.IsSubsetOf(subsetObjectType))
+            throw new IncompatibleTypesOfOperands(
+                visitable.Segment,
+                left: supersetObjectType,
+                right: subsetObjectType);
+
+        visitable.ComputedCopiedProperties = supersetObjectType.CalculateDifference(subsetObjectType);
+
+        return supersetObjectType;
+    }
+
     public Type Visit(CastAsExpression visitable)
     {
         Type undefined = "undefined";

src/Domain/HydraScript.Domain.BackEnd/Impl/Instructions/WithAssignment/ComplexData/Read/DotRead.cs

@@ -10,8 +10,6 @@ public class DotRead(Name @object, IValue property) : Simple(
 {
     private readonly IValue _property = property;
 
-    public string Property => (string)_property.Get(frame: null)!;
-
     public Simple ToAssignment(IValue value) =>
         new DotAssignment(@object.ToString(), _property, value);
 

src/Domain/HydraScript.Domain.Constants/TokenTypes.cs

@@ -59,7 +59,7 @@ public static IEnumerable<Dto> Stream
             yield return new(
                 Tag: "Keyword",
                 Pattern:
-                "(?<![a-zA-Z0-9])(let|const|function|if|else|while|break|continue|return|as|type)(?![a-zA-Z0-9])",
+                "(?<![a-zA-Z0-9])(let|const|function|if|else|while|break|continue|return|as|type|with)(?![a-zA-Z0-9])",
                 Priority: 11);
 
             yield return new(

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Expressions/ComplexLiterals/ArrayLiteral.cs

@@ -10,6 +10,10 @@ public partial class ArrayLiteral : ComplexLiteral
 
     public IReadOnlyList<Expression> Expressions => _expressions;
 
+    public override string Id => Parent is AssignmentExpression assignment
+        ? assignment.Destination.Id
+        : NullId;
+
     public ArrayLiteral(List<Expression> expressions)
     {
         _expressions = expressions;

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Expressions/ComplexLiterals/ComplexLiteral.cs

@@ -2,7 +2,16 @@ namespace HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.ComplexL
 
 public abstract class ComplexLiteral : Expression
 {
-    public string Id => Parent is AssignmentExpression assignment
-        ? assignment.Destination.Id
-        : $"_t{GetHashCode()}";
+    private string? _nullId;
+
+    protected string NullId
+    {
+        get
+        {
+            _nullId ??= $"{GetHashCode()}";
+            return _nullId;
+        }
+    }
+
+    public abstract string Id { get; }
 }

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Expressions/ComplexLiterals/ObjectLiteral.cs

@@ -10,6 +10,20 @@ public partial class ObjectLiteral : ComplexLiteral
 
     public IReadOnlyList<Property> Properties => _properties;
 
+    public override string Id
+    {
+        get
+        {
+            if (Parent is AssignmentExpression assignment) 
+                return assignment.Destination.Id;
+
+            if (Parent is WithExpression{Parent:AssignmentExpression withAssignment})
+                return withAssignment.Destination.Id;
+
+            return NullId;
+        }
+    }
+
     public ObjectLiteral(List<Property> properties)
     {
         _properties = properties;

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Expressions/WithExpression.cs

@@ -0,0 +1,27 @@
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.ComplexLiterals;
+
+namespace HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions;
+
+[AutoVisitable<IAbstractSyntaxTreeNode>]
+public partial class WithExpression : Expression
+{
+    protected override IReadOnlyList<IAbstractSyntaxTreeNode> Children { get; }
+
+    public Expression Expression { get; }
+    public ObjectLiteral ObjectLiteral { get; }
+
+    public IReadOnlyList<string> ComputedCopiedProperties { get; set; } = [];
+
+    public WithExpression(Expression expression, ObjectLiteral objectLiteral)
+    {
+        Expression = expression;
+        Expression.Parent = this;
+
+        ObjectLiteral = objectLiteral;
+        ObjectLiteral.Parent = this;
+
+        Children = [Expression, ObjectLiteral];
+    }
+
+    protected override string NodeRepresentation() => "with";
+}