Feature/explicit cast (#217)

* #202 - refactoring AsString.cs

* #202 - new explicit cast backend instructions

* #202 - static analysis

* #202 - fix

* #202 - type use iequatable

* #202 - codegen

* #202 - improve print codegen

* #202 - fix 2

* #202 - new test

Author: Stepami

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

@@ -5,6 +5,7 @@
 using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ComplexData.Create;
 using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ComplexData.Read;
 using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ComplexData.Write;
+using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ExplicitCast;
 using HydraScript.Domain.BackEnd.Impl.Instructions.WithJump;
 using HydraScript.Domain.BackEnd.Impl.Values;
 using HydraScript.Domain.FrontEnd.Parser;
@@ -150,13 +151,22 @@ public AddressedInstructions Visit(BinaryExpression visitable)
 
     public AddressedInstructions Visit(CastAsExpression visitable)
     {
+        Func<IValue, IExecutableInstruction> asFactory = visitable.ToType switch
+        {
+            CastAsExpression.DestinationType.Undefined => throw new NotSupportedException(),
+            CastAsExpression.DestinationType.String => value => new AsString(value),
+            CastAsExpression.DestinationType.Number => value => new AsNumber(value),
+            CastAsExpression.DestinationType.Boolean => value => new AsBool(value),
+            _ => throw new ArgumentOutOfRangeException(nameof(visitable.ToType))
+        };
+
         if (visitable.Expression is PrimaryExpression primary)
-            return [new AsString(_valueFactory.Create(primary.ToValueDto()))];
-        
+            return [asFactory(_valueFactory.Create(primary.ToValueDto()))];
+
         var result = visitable.Expression.Accept(This);
         var last = result.OfType<Simple>().Last().Left!;
-        result.Add(new AsString(last));
-        
+        result.Add(asFactory(last));
+
         return result;
     }
 

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

@@ -2,6 +2,7 @@
 using HydraScript.Domain.BackEnd.Impl.Addresses;
 using HydraScript.Domain.BackEnd.Impl.Instructions;
 using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment;
+using HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ExplicitCast;
 using HydraScript.Domain.BackEnd.Impl.Instructions.WithJump;
 using HydraScript.Domain.Constants;
 using HydraScript.Domain.FrontEnd.Parser;
@@ -231,18 +232,26 @@ public AddressedInstructions Visit(IfStatement visitable)
 
     public AddressedInstructions Visit(PrintStatement visitable)
     {
-        AddressedInstructions result = [];
-
         if (visitable.Expression is PrimaryExpression prim)
-            result.Add(new AsString(_valueFactory.Create(prim.ToValueDto())));
-        else
         {
-            result.AddRange(visitable.Expression.Accept(_expressionVisitor));
-            var name = result.OfType<Simple>().Last().Left!;
-            result.Add(new AsString(name));
+            var valueDto = prim.ToValueDto();
+            var printedValue = _valueFactory.Create(valueDto);
+            IExecutableInstruction instruction = valueDto is { Type: ValueDtoType.Env } or { Type: ValueDtoType.Constant, Value: string }
+                ? new Print(printedValue)
+                : new AsString(printedValue);
+            AddressedInstructions shortResult = [instruction];
+            if (instruction is AsString asString)
+                shortResult.Add(new Print(asString.Left!));
+            return shortResult;
         }
 
-        result.Add(new Print((result[result.End] as AsString)!.Left!));
+        AddressedInstructions result = [];
+
+        result.AddRange(visitable.Expression.Accept(_expressionVisitor));
+        var name = result.OfType<Simple>().Last().Left!;
+        var nameAsString = new AsString(name);
+        result.Add(nameAsString);
+        result.Add(new Print(nameAsString.Left!));
 
         return result;
     }

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

@@ -0,0 +1,8 @@
+using System.Diagnostics.CodeAnalysis;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions;
+
+namespace HydraScript.Application.StaticAnalysis.Exceptions;
+
+[ExcludeFromCodeCoverage]
+public class ExplicitCastNotSupported(CastAsExpression cast, Type from, Type to) :
+    SemanticException(cast.Segment, $"Cast from {from} to {to} is not supported");

src/Application/HydraScript.Application.StaticAnalysis/IExplicitCastValidator.cs

@@ -0,0 +1,6 @@
+namespace HydraScript.Application.StaticAnalysis;
+
+public interface IExplicitCastValidator
+{
+    bool IsAllowed(Type from, Type to);
+}

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

@@ -0,0 +1,37 @@
+using HydraScript.Domain.IR.Types;
+
+namespace HydraScript.Application.StaticAnalysis.Impl;
+
+internal sealed class ExplicitCastValidator : IExplicitCastValidator
+{
+    private static readonly Type Boolean = "boolean";
+    private static readonly Type Number = "number";
+    private static readonly Type String = "string";
+    private static readonly Any Any = new();
+
+    private readonly Dictionary<Type, List<Type>> _allowedConversions = new()
+    {
+        { String, [Any] },
+        { Number, [String, Boolean] },
+        { Boolean, [String, Number] },
+    };
+
+    public bool IsAllowed(Type from, Type to)
+    {
+        var typeEqualityComparer = default(CommutativeTypeEqualityComparer);
+
+        if (typeEqualityComparer.Equals(from, to))
+            return true;
+
+        if (!_allowedConversions.TryGetValue(to, out var allowedFrom))
+            return false;
+
+        for (var i = 0; i < allowedFrom.Count; i++)
+        {
+            if (typeEqualityComparer.Equals(allowedFrom[i], from))
+                return true;
+        }
+
+        return false;
+    }
+}

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

@@ -21,6 +21,7 @@ public static IServiceCollection AddStaticAnalysis(this IServiceCollection servi
         services.AddSingleton<IStandardLibraryProvider, StandardLibraryProvider>();
         services.AddSingleton<IJavaScriptTypesProvider, JavaScriptTypesProvider>();
         services.AddSingleton<IDefaultValueForTypeCalculator, DefaultValueForTypeCalculator>();
+        services.AddSingleton<IExplicitCastValidator, ExplicitCastValidator>();
 
         services.AddSingleton<IAmbiguousInvocationStorage, AmbiguousInvocationStorage>();
 

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

@@ -50,6 +50,7 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     private readonly ISymbolTableStorage _symbolTables;
     private readonly IComputedTypesStorage _computedTypes;
     private readonly IAmbiguousInvocationStorage _ambiguousInvocations;
+    private readonly IExplicitCastValidator _explicitCastValidator;
     private readonly IVisitor<TypeValue, Type> _typeBuilder;
 
     public SemanticChecker(
@@ -59,6 +60,7 @@ public SemanticChecker(
         ISymbolTableStorage symbolTables,
         IComputedTypesStorage computedTypes,
         IAmbiguousInvocationStorage ambiguousInvocations,
+        IExplicitCastValidator explicitCastValidator,
         IVisitor<TypeValue, Type> typeBuilder)
     {
         _calculator = calculator;
@@ -67,6 +69,7 @@ public SemanticChecker(
         _symbolTables = symbolTables;
         _computedTypes = computedTypes;
         _ambiguousInvocations = ambiguousInvocations;
+        _explicitCastValidator = explicitCastValidator;
         _typeBuilder = typeBuilder;
     }
 
@@ -84,7 +87,7 @@ public Type Visit(ScriptBody visitable)
         _symbolTables.Clear();
         _computedTypes.Clear();
         _ambiguousInvocations.Clear();
-        
+
         return "undefined";
     }
 
@@ -433,14 +436,23 @@ public ObjectType Visit(WithExpression visitable)
     public Type Visit(CastAsExpression visitable)
     {
         Type undefined = "undefined";
-        var exprType = visitable.Expression.Accept(This);
+        var from = visitable.Expression.Accept(This);
 
-        if (exprType.Equals(undefined))
+        if (from.Equals(undefined))
             throw new CannotDefineType(visitable.Expression.Segment);
 
-        return visitable.Cast.Accept(_typeBuilder) == "string"
-            ? "string"
-            : throw new NotSupportedException("Other types but 'string' have not been supported for casting yet");
+        var to = visitable.Cast.Accept(_typeBuilder);
+        visitable.ToType = to switch
+        {
+            _ when to.Equals("string") => CastAsExpression.DestinationType.String,
+            _ when to.Equals("number") => CastAsExpression.DestinationType.Number,
+            _ when to.Equals("boolean") => CastAsExpression.DestinationType.Boolean,
+            _ => CastAsExpression.DestinationType.Undefined
+        };
+
+        return _explicitCastValidator.IsAllowed(from, to)
+            ? to
+            : throw new ExplicitCastNotSupported(visitable, from, to);
     }
 
     public Type Visit(CallExpression visitable)

src/Domain/HydraScript.Domain.BackEnd/Impl/Instructions/WithAssignment/ExplicitCast/AsBool.cs

@@ -0,0 +1,7 @@
+namespace HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ExplicitCast;
+
+public class AsBool(IValue value) : AsInstruction<bool>(value)
+{
+    protected override bool Convert(object? value) =>
+        System.Convert.ToBoolean(value);
+}

src/Domain/HydraScript.Domain.BackEnd/Impl/Instructions/WithAssignment/ExplicitCast/AsInstruction.cs

@@ -0,0 +1,16 @@
+namespace HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ExplicitCast;
+
+public abstract class AsInstruction<T>(IValue value) : Simple(value)
+{
+    protected override void Assign()
+    {
+        var value = Right.right!.Get();
+        var valueAsType = value is T ? value : Convert(value);
+        Left?.Set(valueAsType);
+    }
+
+    protected abstract T Convert(object? value);
+
+    protected override string ToStringInternal() =>
+        $"{Left} = {Right.right} as {typeof(T).Name}";
+}

src/Domain/HydraScript.Domain.BackEnd/Impl/Instructions/WithAssignment/ExplicitCast/AsNumber.cs

@@ -0,0 +1,7 @@
+namespace HydraScript.Domain.BackEnd.Impl.Instructions.WithAssignment.ExplicitCast;
+
+public class AsNumber(IValue value) : AsInstruction<double>(value)
+{
+    protected override double Convert(object? value) =>
+        System.Convert.ToDouble(value);
+}