#201 - refactoring + tests

Author: Stepami

src/Application/HydraScript.Application.StaticAnalysis/IDefaultValueForTypeCalculator.cs

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

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

@@ -24,8 +24,7 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     IVisitor<ReturnStatement, Type>,
     IVisitor<ExpressionStatement, Type>,
     IVisitor<IdentifierReference, Type>,
-    IVisitor<Literal, Type>,
-    IVisitor<ImplicitLiteral, Type>,
+    IVisitor<AbstractLiteral, Type>,
     IVisitor<ArrayLiteral, ArrayType>,
     IVisitor<ObjectLiteral, ObjectType>,
     IVisitor<ConditionalExpression, Type>,
@@ -43,7 +42,6 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     IVisitor<BlockStatement, Type>,
     IVisitor<PrintStatement, Type>
 {
-    private readonly IDefaultValueForTypeCalculator _calculator;
     private readonly IFunctionWithUndefinedReturnStorage _functionStorage;
     private readonly IMethodStorage _methodStorage;
     private readonly ISymbolTableStorage _symbolTables;
@@ -52,15 +50,13 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     private readonly IVisitor<TypeValue, Type> _typeBuilder;
 
     public SemanticChecker(
-        IDefaultValueForTypeCalculator calculator,
         IFunctionWithUndefinedReturnStorage functionStorage,
         IMethodStorage methodStorage,
         ISymbolTableStorage symbolTables,
         IComputedTypesStorage computedTypes,
         IAmbiguousInvocationStorage ambiguousInvocations,
         IVisitor<TypeValue, Type> typeBuilder)
     {
-        _calculator = calculator;
         _functionStorage = functionStorage;
         _methodStorage = methodStorage;
         _symbolTables = symbolTables;
@@ -154,16 +150,9 @@ public Type Visit(IdentifierReference visitable)
         return symbol?.Type ?? throw new UnknownIdentifierReference(visitable);
     }
 
-    public Type Visit(Literal visitable) =>
+    public Type Visit(AbstractLiteral visitable) =>
         visitable.Type.Accept(_typeBuilder);
 
-    public Type Visit(ImplicitLiteral visitable)
-    {
-        var type = visitable.Type.Accept(_typeBuilder);
-        visitable.ComputedDefaultValue = _calculator.GetDefaultValueForType(type);
-        return type;
-    }
-
     public ArrayType Visit(ArrayLiteral visitable)
     {
         if (visitable.Expressions.Count == 0)

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

@@ -12,6 +12,12 @@ public abstract record TypeValue : IVisitable<TypeValue>
 [AutoVisitable<TypeValue>]
 public partial record TypeIdentValue(IdentifierReference TypeId) : TypeValue
 {
+    public static TypeValue String => new TypeIdentValue(new IdentifierReference("string"));
+    public static TypeValue Number => new TypeIdentValue(new IdentifierReference("number"));
+    public static TypeValue Boolean => new TypeIdentValue(new IdentifierReference("boolean"));
+    public static TypeValue Null => new TypeIdentValue(new IdentifierReference("null"));
+    public static TypeValue Undefined => new TypeIdentValue(new IdentifierReference("undefined"));
+
     public override string ToString() => TypeId;
 }
 

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

@@ -2,7 +2,8 @@
 
 namespace HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryExpressions;
 
-public abstract class AbstractLiteral(TypeValue type) : PrimaryExpression
+[AutoVisitable<IAbstractSyntaxTreeNode>]
+public abstract partial class AbstractLiteral(TypeValue type) : PrimaryExpression
 {
     public TypeValue Type { get; } = type;
 

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/Nodes/Declarations/TypeValue.cs

@@ -5,15 +5,23 @@ namespace HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryE
 [AutoVisitable<IAbstractSyntaxTreeNode>]
 public partial class ImplicitLiteral(TypeValue type) : AbstractLiteral(type)
 {
-    public object? ComputedDefaultValue { private get; set; }
+    private readonly object? _defaultValue = type switch
+    {
+        TypeIdentValue { TypeId.Name: "string" } => string.Empty,
+        TypeIdentValue { TypeId.Name: "number" } => 0,
+        TypeIdentValue { TypeId.Name: "boolean" } => false,
+        TypeIdentValue { TypeId.Name: "null" } or NullableTypeValue => null,
+        ArrayTypeValue => new List<object>(),
+        _ => new()
+    };
 
     protected override string NodeRepresentation() =>
         $"Implicit {Type}";
 
     public override ValueDto ToValueDto() =>
         ValueDto.ConstantDto(
-            ComputedDefaultValue,
-            ComputedDefaultValue is null
+            _defaultValue,
+            _defaultValue is null
                 ? "null"
-                : ComputedDefaultValue.ToString()!);
+                : _defaultValue.ToString()!);
 }

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

@@ -25,18 +25,14 @@ public override ValueDto ToValueDto() =>
         ValueDto.ConstantDto(_value, _label);
 
     public static Literal String(string value, string? segment = null, string? label = null) =>
-        new(new TypeIdentValue(new IdentifierReference(name: "string")), value, segment ?? "(1, 1)-(1, 1)", label);
+        new(TypeIdentValue.String, value, segment ?? "(1, 1)-(1, 1)", label);
 
     public static Literal Number(double value, string? segment = null) =>
-        new(new TypeIdentValue(new IdentifierReference(name: "number")), value, segment ?? "(1, 1)-(1, 1)");
+        new(TypeIdentValue.Number, value, segment ?? "(1, 1)-(1, 1)");
 
     public static Literal Boolean(bool value, string? segment = null) =>
-        new(new TypeIdentValue(new IdentifierReference(name: "boolean")), value, segment ?? "(1, 1)-(1, 1)");
+        new(TypeIdentValue.Boolean, value, segment ?? "(1, 1)-(1, 1)");
 
     public static Literal Null(string? segment = null) =>
-        new(
-            new TypeIdentValue(new IdentifierReference(name: "null")),
-            value: null,
-            segment ?? "(1, 1)-(1, 1)",
-            label: "null");
+        new(TypeIdentValue.Null, value: null, segment ?? "(1, 1)-(1, 1)", label: "null");
 }

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

@@ -412,9 +412,7 @@ private void AddToDeclaration(LexicalDeclaration declaration)
         var identRef = new IdentifierReference(ident.Value) { Segment = ident.Segment };
         var assignment = new AssignmentExpression(
                 new MemberExpression(identRef),
-                new ImplicitLiteral(
-                    new TypeIdentValue(
-                        new IdentifierReference("undefined"))))
+                new ImplicitLiteral(TypeIdentValue.Undefined))
             { Segment = ident.Segment };
 
         if (CurrentIs("Assign"))

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

@@ -22,8 +22,8 @@ public void Visit_FunctionWithMissingReturn_CodePathEndedWithReturnIsFalse()
         // Arrange
         var functionDeclaration = new FunctionDeclaration(
             new IdentifierReference("f"),
-            new TypeIdentValue(new IdentifierReference("undefined")),
-            [new NamedArgument("b", new TypeIdentValue(new IdentifierReference("boolean")))],
+            TypeIdentValue.Undefined,
+            [new NamedArgument("b", TypeIdentValue.Boolean)],
             new BlockStatement([
                 new IfStatement(
                     new IdentifierReference("b"),