#202 - static analysis

Author: Stepami

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,16 @@ 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);
+
+        return _explicitCastValidator.IsAllowed(from, to)
+            ? to
+            : throw new ExplicitCastNotSupported(visitable, from, to);
     }
 
     public Type Visit(CallExpression visitable)

src/Domain/HydraScript.Domain.IR/Types/CommutativeTypeEqualityComparer.cs

@@ -0,0 +1,9 @@
+namespace HydraScript.Domain.IR.Types;
+
+public readonly ref struct CommutativeTypeEqualityComparer : IEqualityComparer<Type>
+{
+    public bool Equals(Type? x, Type? y) =>
+        x?.Equals(y) != false || y?.Equals(x) != false;
+
+    public int GetHashCode(Type obj) => obj.GetHashCode();
+}

tests/HydraScript.UnitTests/Application/ExplicitCastValidatorTests.cs

@@ -0,0 +1,28 @@
+using HydraScript.Application.StaticAnalysis.Impl;
+using HydraScript.Domain.IR.Types;
+
+namespace HydraScript.UnitTests.Application;
+
+public class ExplicitCastValidatorTests
+{
+    private readonly ExplicitCastValidator _explicitCastValidator = new();
+
+    [Theory, MemberData(nameof(ConversionsData))]
+    public void IsAllowed_Always_Success(Type from, Type to, bool expected) =>
+        _explicitCastValidator.IsAllowed(from, to).Should().Be(expected);
+
+    public static TheoryData<Type, Type, bool> ConversionsData =>
+        new()
+        {
+            { new ObjectType([]), "string", true },
+            { "number", new NullableType("number"), true },
+            { new NullableType("number"), "number", true },
+            { "string", "number", true },
+            { "string", "boolean", true },
+            { "boolean", "number", true },
+            { "number", "boolean", true },
+            { new ObjectType([]), "boolean", false },
+            { new ArrayType("number"), "number", false },
+            { new ArrayType("number"), new NullableType("boolean"), false },
+        };
+}

tests/HydraScript.UnitTests/Domain/BackEnd/InstructionsData.cs

@@ -19,7 +19,7 @@ public InstructionsData()
             {
                 Left = Name("str")
             },
-            "str = num as string");
+            "str = num as String");
         Add(
             new BeginBlock(BlockType.Function, blockId: "func")
             {