Проверка инициализации переменной +semver:feature (#98)

* fix

* Контракт exit codes

* изменение области видимости

* #84 - подготовил интеграционники для скриптов с семантическими ошибками

* #84 - реализация фичи

* #84 - подправил тесты

Author: Stepami

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

@@ -0,0 +1,9 @@
+using System.Diagnostics.CodeAnalysis;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Expressions.PrimaryExpressions;
+
+namespace HydraScript.Application.StaticAnalysis.Exceptions;
+
+[ExcludeFromCodeCoverage]
+public class AccessBeforeInitialization(IdentifierReference variable) : SemanticException(
+    variable.Segment,
+    $"Cannot access '{variable.Name}' before initialization");

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

@@ -74,6 +74,7 @@ public VisitUnit Visit(FunctionDeclaration visitable)
             var arg = new VariableSymbol(
                 id: x.Key,
                 x.TypeValue.Accept(_typeBuilder));
+            arg.Initialize();
             _symbolTables[visitable.Scope].AddSymbol(arg);
             return arg;
         }).ToList();

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

@@ -137,6 +137,8 @@ public Type Visit(ExpressionStatement visitable) =>
     public Type Visit(IdentifierReference visitable)
     {
         var symbol = _symbolTables[visitable.Scope].FindSymbol<ISymbol>(visitable.Name);
+        if (symbol is { Initialized: false })
+            throw new AccessBeforeInitialization(visitable);
         return symbol?.Type ?? throw new UnknownIdentifierReference(visitable);
     }
 
@@ -167,11 +169,13 @@ public Type Visit(ObjectLiteral visitable)
         var properties = visitable.Properties.Select(prop =>
         {
             var propType = prop.Expression.Accept(This);
-            _symbolTables[visitable.Scope].AddSymbol(propType switch
+            var propSymbol = propType switch
             {
                 ObjectType objectType => new ObjectSymbol(prop.Id, objectType),
                 _ => new VariableSymbol(prop.Id, propType)
-            });
+            };
+            propSymbol.Initialize();
+            _symbolTables[visitable.Scope].AddSymbol(propSymbol);
             return new PropertyType(prop.Id, propType);
         });
         var objectLiteralType = new ObjectType(properties);
@@ -282,6 +286,7 @@ public Type Visit(LexicalDeclaration visitable)
                 ObjectType objectType => new ObjectSymbol(registeredSymbol.Id, objectType, visitable.ReadOnly),
                 _ => new VariableSymbol(registeredSymbol.Id, actualType, visitable.ReadOnly)
             };
+            actualSymbol.Initialize();
             _symbolTables[visitable.Scope].AddSymbol(actualSymbol);
         }
 

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

@@ -8,7 +8,7 @@ public partial class ImplicitLiteral(TypeValue type) : AbstractLiteral(type)
     public object? ComputedDefaultValue { private get; set; }
 
     protected override string NodeRepresentation() =>
-        Type.ToString();
+        $"Implicit {Type}";
 
     public override ValueDto ToValueDto() =>
         ValueDto.ConstantDto(

src/Domain/HydraScript.Domain.IR/ISymbol.cs

@@ -4,4 +4,5 @@ public interface ISymbol
 {
     public string Id { get; }
     public Type Type { get; }
+    public bool Initialized { get; }
 }

src/Domain/HydraScript.Domain.IR/Impl/Symbols/Symbol.cs

@@ -4,4 +4,5 @@ public abstract class Symbol(string id, Type type) : ISymbol
 {
     public virtual string Id { get; } = id;
     public virtual Type Type { get; } = type;
+    public virtual bool Initialized => true;
 }

src/Domain/HydraScript.Domain.IR/Impl/Symbols/VariableSymbol.cs

@@ -5,7 +5,12 @@ public class VariableSymbol(
     Type type,
     bool readOnly = false) : Symbol(id, type)
 {
+    private bool _initialized = readOnly;
+
     public bool ReadOnly { get; } = readOnly;
+    public override bool Initialized => _initialized;
+
+    public void Initialize() => _initialized = true;
 
     public override string ToString() =>
         $"{(ReadOnly ? "const " : "")}{Id}: {Type}";

src/HydraScript/ExecuteCommand.cs

@@ -2,9 +2,9 @@
 
 namespace HydraScript;
 
-public class ExecuteCommand : RootCommand
+internal class ExecuteCommand : RootCommand
 {
-    public ExecuteCommand() : base("HydraScript interpreter")
+    internal ExecuteCommand() : base("HydraScript interpreter")
     {
         PathArgument = new Argument<FileInfo>(
             name: "path",
@@ -18,6 +18,6 @@ public ExecuteCommand() : base("HydraScript interpreter")
         AddOption(DumpOption);
     }
 
-    public Argument<FileInfo> PathArgument { get; }
-    public Option<bool> DumpOption { get; }
+    internal Argument<FileInfo> PathArgument { get; }
+    internal Option<bool> DumpOption { get; }
 }

src/HydraScript/ExecuteCommandHandler.cs

@@ -24,19 +24,19 @@ public int Invoke(InvocationContext context)
             var ast = parser.Parse(sourceCode);
             var instructions = codeGenerator.GetInstructions(ast);
             virtualMachine.Run(instructions);
-            return 0;
+            return ExitCodes.Success;
         }
         catch (Exception ex)
             when (ex is LexerException or ParserException or SemanticException)
         {
             writer.WriteLine(ex.Message);
-            return 1;
+            return ExitCodes.HydraScriptError;
         }
         catch (Exception ex)
         {
             writer.WriteLine("Internal HydraScript Error");
             writer.WriteLine(ex);
-            return 2;
+            return ExitCodes.DotnetRuntimeError;
         }
     }
 

src/HydraScript/ExitCodes.cs

@@ -0,0 +1,10 @@
+namespace HydraScript;
+
+internal static class ExitCodes
+{
+    public const int Success = 0;
+
+    public const int HydraScriptError = 1;
+
+    public const int DotnetRuntimeError = 2;
+}