#56 - запретит присваивания null в ситуациях неопределённого типа (#124)

* #56 - доработка ChildOf: условие для родителя

* #56 - запреты на присваивание null

* #56 - тесты

Author: Stepami

samples/linkedlist.js

@@ -16,7 +16,7 @@ function append(lst: list, item: number) {
 
 function getOdd(lst: list): number[] {
     let result: number[]
-    let n = lst.head
+    let n: node = lst.head
     while (n != null) {
         if (n.data % 2 != 0) {
             let i = n.data

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

@@ -0,0 +1,7 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace HydraScript.Application.StaticAnalysis.Exceptions;
+
+[ExcludeFromCodeCoverage]
+public class CannotAssignNullWhenUndefined(string segment) :
+    SemanticException(segment, "Cannot assign 'null' when type is undefined");

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

@@ -157,7 +157,7 @@ public Type Visit(ArrayLiteral visitable)
         if (visitable.Expressions.Count == 0)
             return new ArrayType(new Any());
 
-        var type = visitable.First().Accept(This);
+        var type = visitable[0].Accept(This);
         if (visitable.Expressions.All(e => e.Accept(This).Equals(type)))
             return new ArrayType(type);
 
@@ -169,6 +169,14 @@ public Type Visit(ObjectLiteral visitable)
         var properties = visitable.Properties.Select(prop =>
         {
             var propType = prop.Expression.Accept(This);
+
+            if (propType is NullType &&
+                (visitable.ChildOf<AssignmentExpression>(
+                     x => x.ChildOf<LexicalDeclaration>() && x.DestinationType is null) ||
+                 visitable.ChildOf<ReturnStatement>(x => x.ChildOf<FunctionDeclaration>(
+                     decl => decl.ReturnTypeValue is TypeIdentValue { TypeId.Name: "undefined" }))))
+                throw new CannotAssignNullWhenUndefined(prop.Segment);
+
             var propSymbol = propType switch
             {
                 ObjectType objectType => new ObjectSymbol(prop.Id, objectType),
@@ -279,6 +287,8 @@ public Type Visit(LexicalDeclaration visitable)
                     assignment.Segment,
                     left: registeredSymbol.Type,
                     right: sourceType);
+            if (sourceType is NullType && registeredSymbol.Type.Equals(undefined))
+                throw new CannotAssignNullWhenUndefined(assignment.Segment);
 
             var actualType = registeredSymbol.Type.Equals(undefined)
                 ? sourceType
@@ -480,6 +490,9 @@ public Type Visit(FunctionDeclaration visitable)
         if (!symbol.Type.Equals(@void) && !hasReturnStatement)
             throw new FunctionWithoutReturnStatement(visitable.Segment);
 
+        if (symbol.Type is NullType)
+            throw new CannotAssignNullWhenUndefined(visitable.Segment);
+
         return symbol.Type;
     }
 

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/Ast/AbstractSyntaxTreeNode.cs

@@ -41,14 +41,22 @@ public IReadOnlyList<IAbstractSyntaxTreeNode> GetAllNodes()
         return result;
     }
 
-    public bool ChildOf<T>() where T : IAbstractSyntaxTreeNode
+    /// <summary>
+    /// Метод возвращает <c>true</c>, если узел - потомок заданного типа и выполняется заданное условие.<br/>
+    /// В случае, когда условие не задано, проверяется просто соответствие типов.
+    /// </summary>
+    /// <param name="condition">Условие для родителя</param>
+    /// <typeparam name="T">Проверяемый тип родителя</typeparam>
+    public bool ChildOf<T>(Predicate<T>? condition = null) where T : IAbstractSyntaxTreeNode
     {
         var parent = Parent;
         while (parent != default!)
         {
-            if (parent is T)
+            if (parent is T node)
             {
-                return true;
+                return condition is not null
+                    ? condition(node)
+                    : true;
             }
 
             parent = parent.Parent;

src/Domain/HydraScript.Domain.FrontEnd/Parser/Impl/TopDownParser.cs

@@ -721,7 +721,7 @@ private ObjectLiteral ObjectLiteral()
 
             Expect("Colon");
             var expr = Expression();
-            properties.Add(new Property(id, expr));
+            properties.Add(new Property(id, expr) { Segment = idToken.Segment });
 
             Expect("SemiColon");
         }

tests/HydraScript.IntegrationTests/ErrorPrograms/NullAssignmentWhenUndefinedTests.cs

@@ -0,0 +1,32 @@
+using System.CommandLine.Parsing;
+
+namespace HydraScript.IntegrationTests.ErrorPrograms;
+
+public class NullAssignmentWhenUndefinedTests(TestHostFixture fixture) : IClassFixture<TestHostFixture>
+{
+    [Theory, MemberData(nameof(NullAssignmentScripts))]
+    public void NullAssignment_UndefinedDestinationOrReturnType_HydraScriptError(string script)
+    {
+        var runner = fixture.GetRunner(
+            configureTestServices: services =>
+                services.SetupInMemoryScript(script));
+        var code = runner.Invoke(fixture.InMemoryScript);
+        code.Should().Be(ExitCodes.HydraScriptError);
+        fixture.LogMessages.Should()
+            .Contain(x => x.Contains("Cannot assign 'null' when type is undefined"));
+    }
+
+    public static TheoryData<string> NullAssignmentScripts
+    {
+        get
+        {
+            const string lexicalDeclaration = "let x = null";
+            const string objectLiteralProperty = "let y = {prop: null;}";
+            const string functionReturn = "function f() { return null }";
+            return new TheoryData<string>([
+                lexicalDeclaration,
+                objectLiteralProperty,
+                functionReturn]);
+        }
+    }
+}

tests/HydraScript.IntegrationTests/ErrorPrograms/VariableInitializationTests.cs

@@ -5,7 +5,7 @@ namespace HydraScript.IntegrationTests.ErrorPrograms;
 public class VariableInitializationTests(TestHostFixture fixture) : IClassFixture<TestHostFixture>
 {
     [Theory, MemberData(nameof(VariableInitializationScripts))]
-    public void VariableWithoutTypeDeclared_AccessedBeforeInitialization_ExitCodeHydraScriptError(string script)
+    public void VariableWithoutTypeDeclared_AccessedBeforeInitialization_HydraScriptError(string script)
     {
         var runner = fixture.GetRunner(
             configureTestServices: services =>
@@ -36,7 +36,9 @@ function f() {
                     return 5
                 }
                 """;
-            return new TheoryData<string>([variableWithoutTypeDeclared, typedVariableDeclared]);
+            return new TheoryData<string>([
+                variableWithoutTypeDeclared,
+                typedVariableDeclared]);
         }
     }
 }

tests/HydraScript.IntegrationTests/ErrorPrograms/VoidAssignmentTests.cs

@@ -5,7 +5,7 @@ namespace HydraScript.IntegrationTests.ErrorPrograms;
 public class VoidAssignmentTests(TestHostFixture fixture) : IClassFixture<TestHostFixture>
 {
     [Fact]
-    public void FunctionDeclared_VoidReturnAssigned_ExitCodeHydraScriptError()
+    public void FunctionDeclared_VoidReturnAssigned_HydraScriptError()
     {
         const string script =
             """