#201 - fix ImplicitLiteral.cs

Author: Stepami

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

@@ -20,6 +20,7 @@ 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/Visitors/SemanticChecker.cs

@@ -24,7 +24,8 @@ internal class SemanticChecker : VisitorBase<IAbstractSyntaxTreeNode, Type>,
     IVisitor<ReturnStatement, Type>,
     IVisitor<ExpressionStatement, Type>,
     IVisitor<IdentifierReference, Type>,
-    IVisitor<AbstractLiteral, Type>,
+    IVisitor<Literal, Type>,
+    IVisitor<ImplicitLiteral, Type>,
     IVisitor<ArrayLiteral, ArrayType>,
     IVisitor<ObjectLiteral, ObjectType>,
     IVisitor<ConditionalExpression, Type>,
@@ -42,6 +43,7 @@ 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;
@@ -50,13 +52,15 @@ 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;
@@ -150,9 +154,21 @@ public Type Visit(IdentifierReference visitable)
         return symbol?.Type ?? throw new UnknownIdentifierReference(visitable);
     }
 
-    public Type Visit(AbstractLiteral visitable) =>
+    public Type Visit(Literal visitable) =>
         visitable.Type.Accept(_typeBuilder);
 
+    public Type Visit(ImplicitLiteral visitable)
+    {
+        var type = visitable.Type.Accept(_typeBuilder);
+        if (!visitable.IsDefined)
+        {
+            var definedValue = _calculator.GetDefaultValueForType(type);
+            visitable.SetValue(definedValue);
+        }
+
+        return type;
+    }
+
     public ArrayType Visit(ArrayLiteral visitable)
     {
         if (visitable.Expressions.Count == 0)

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

@@ -5,23 +5,29 @@ namespace HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryE
 [AutoVisitable<IAbstractSyntaxTreeNode>]
 public partial class ImplicitLiteral(TypeValue type) : AbstractLiteral(type)
 {
-    private readonly object? _defaultValue = type switch
+    private 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()
+        _ => new Undefined()
     };
 
     protected override string NodeRepresentation() =>
         $"Implicit {Type}";
 
+    public void SetValue(object? value) => _defaultValue = value;
+
+    public bool IsDefined => _defaultValue is not Undefined;
+
     public override ValueDto ToValueDto() =>
         ValueDto.ConstantDto(
             _defaultValue,
             _defaultValue is null
                 ? "null"
                 : _defaultValue.ToString()!);
+
+    private sealed class Undefined;
 }

tests/HydraScript.IntegrationTests/Samples/defaultarray.js

@@ -2,4 +2,5 @@ type numbers = number[]
 
 let a: numbers
 
->>>a
+>>>a
+>>>~a

tests/HydraScript.IntegrationTests/Samples/xxx.js

@@ -1,7 +1,8 @@
 type x = number
 let x:x
 function x(x:x) {
->>>x
+    >>>x
+    x = x + 1
 }
 
 x(x)

tests/HydraScript.UnitTests/Domain/FrontEnd/ImplicitLiteralTests.cs

@@ -13,11 +13,10 @@ public void ToValueDto_Always_Expected(ImplicitLiteral implicitLiteral, object?
     }
 
     [Fact]
-    public void ToValueDto_Undefined_DefaultValueIsNewObject()
+    public void ToValueDto_Undefined_DefaultValueIsUndefined()
     {
         var implicitLiteral = new ImplicitLiteral(TypeIdentValue.Undefined);
-        var actual = implicitLiteral.ToValueDto().Value;
-        actual.Should().BeOfType<object>();
+        implicitLiteral.IsDefined.Should().BeFalse();
     }
 
     public static TheoryData<ImplicitLiteral, object?> ToValueDtoData =>