#42 - внедрил system command line

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

@@ -1,6 +1,7 @@
 using HydraScript.Application.StaticAnalysis.Impl;
 using HydraScript.Application.StaticAnalysis.Visitors;
 using HydraScript.Domain.FrontEnd.Parser;
+using HydraScript.Domain.FrontEnd.Parser.Impl.Ast.Nodes.Declarations;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace HydraScript.Application.StaticAnalysis;
@@ -20,9 +21,11 @@ public static IServiceCollection AddStaticAnalysis(this IServiceCollection servi
         services.AddTransient<IJavaScriptTypesProvider, JavaScriptTypesProvider>();
         services.AddTransient<IDefaultValueForTypeCalculator, DefaultValueForTypeCalculator>();
 
+        services.AddTransient<IVisitor<TypeValue, Type>, TypeBuilder>();
+
         services.AddTransient<IVisitor<IAbstractSyntaxTreeNode>, SymbolTableInitializer>();
-        services.AddTransient<IVisitor<IAbstractSyntaxTreeNode, TypeSystemLoader>>();
-        services.AddTransient<IVisitor<IAbstractSyntaxTreeNode, DeclarationVisitor>>();
+        services.AddTransient<IVisitor<IAbstractSyntaxTreeNode>, TypeSystemLoader>();
+        services.AddTransient<IVisitor<IAbstractSyntaxTreeNode>, DeclarationVisitor>();
 
         services.AddTransient<IVisitor<IAbstractSyntaxTreeNode, Type>, SemanticChecker>();
 

src/HydraScript/ExecuteCommand.cs

@@ -0,0 +1,23 @@
+using System.CommandLine;
+
+namespace HydraScript;
+
+internal class ExecuteCommand : RootCommand
+{
+    public ExecuteCommand() : base("HydraScript interpreter")
+    {
+        PathArgument = new Argument<FileInfo>(
+            name: "path",
+            description: "Path to input file");
+        AddArgument(PathArgument);
+
+        DumpOption = new Option<bool>(
+            ["-d", "--dump"],
+            getDefaultValue: () => false,
+            description: "Show dump data of interpreter");
+        AddOption(DumpOption);
+    }
+
+    public Argument<FileInfo> PathArgument { get; }
+    public Option<bool> DumpOption { get; }
+}

src/HydraScript/ExecuteCommandHandler.cs

@@ -0,0 +1,45 @@
+using System.CommandLine.Invocation;
+using HydraScript.Application.CodeGeneration;
+using HydraScript.Application.StaticAnalysis.Exceptions;
+using HydraScript.Domain.BackEnd;
+using HydraScript.Domain.FrontEnd.Lexer;
+using HydraScript.Domain.FrontEnd.Parser;
+using HydraScript.Infrastructure;
+
+namespace HydraScript;
+
+internal class ExecuteCommandHandler(
+    ISourceCodeProvider sourceCodeProvider,
+    IParser parser,
+    ICodeGenerator codeGenerator,
+    IVirtualMachine virtualMachine,
+    TextWriter writer) : ICommandHandler
+{
+
+    public int Invoke(InvocationContext context)
+    {
+        try
+        {
+            var sourceCode = sourceCodeProvider.GetText();
+            var ast = parser.Parse(sourceCode);
+            var instructions = codeGenerator.GetInstructions(ast);
+            virtualMachine.Run(instructions);
+            return 0;
+        }
+        catch (Exception ex)
+            when (ex is LexerException or ParserException or SemanticException)
+        {
+            writer.WriteLine(ex.Message);
+            return 1;
+        }
+        catch (Exception ex)
+        {
+            writer.WriteLine("Internal HydraScript Error");
+            writer.WriteLine(ex);
+            return 2;
+        }
+    }
+
+    public Task<int> InvokeAsync(InvocationContext context) =>
+        Task.FromResult(Invoke(context));
+}

src/HydraScript/HydraScript.csproj

@@ -14,10 +14,8 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="CommandLineParser" Version="2.9.1" />
-      <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-      <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.1" />
-      <PackageReference Include="System.IO.Abstractions" Version="19.2.18" />
+      <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
+      <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
     </ItemGroup>
 
 </Project>

src/HydraScript/Program.cs

@@ -1,61 +1,28 @@
-using System.Diagnostics.CodeAnalysis;
-using System.IO.Abstractions;
-using CommandLine;
-using HydraScript.Domain.FrontEnd.Lexer;
-using HydraScript.Domain.FrontEnd.Lexer.Impl;
-using HydraScript.Lib.FrontEnd.GetTokens;
-using HydraScript.Services.CodeGen;
-using HydraScript.Services.CodeGen.Impl;
-using HydraScript.Services.Executor;
-using HydraScript.Services.Executor.Impl;
-using HydraScript.Services.Parsing;
-using HydraScript.Services.Parsing.Impl;
-using HydraScript.Services.Providers.LexerProvider;
-using HydraScript.Services.Providers.LexerProvider.Impl;
-using HydraScript.Services.Providers.ParserProvider;
-using HydraScript.Services.Providers.ParserProvider.Impl;
-using HydraScript.Services.Providers.StructureProvider;
-using HydraScript.Services.Providers.StructureProvider.Impl;
-using HydraScript.Services.SourceCode;
-using HydraScript.Services.SourceCode.Impl;
+using System.CommandLine.Builder;
+using System.CommandLine.Hosting;
+using System.CommandLine.Parsing;
+using HydraScript;
+using HydraScript.Infrastructure;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 
-namespace HydraScript;
-
-[ExcludeFromCodeCoverage]
-public static class Program
-{
-    private static IServiceCollection ServiceCollection { get; } = new ServiceCollection();
-    private static IServiceProvider? ServiceProvider { get; set; }
-
-    private static void Main(string[] args) =>
-        Parser.Default.ParseArguments<CommandLineSettings>(args)
-            .WithParsed(options =>
+var command = new ExecuteCommand();
+var runner = new CommandLineBuilder(command)
+    .UseHost(
+        Host.CreateDefaultBuilder,
+        configureHost: builder => builder
+            .ConfigureServices((context, services) =>
             {
-                ConfigureServices(options);
-                ServiceProvider?
-                    .GetService<IExecutor>()!
-                    .Execute();
+                services.AddLogging(c => c.ClearProviders());
+                var parseResult = context.GetInvocationContext().ParseResult;
+                var fileInfo = parseResult.GetValueForArgument(command.PathArgument);
+                var dump = parseResult.GetValueForOption(command.DumpOption);
+                services.AddDomain();
+                services.AddApplication();
+                services.AddInfrastructure(dump, fileInfo);
             })
-            .WithNotParsed(errors => errors.Output());
-
-
-    private static void ConfigureServices(CommandLineSettings settings)
-    {
-        ServiceCollection.AddSingleton<IStructureProvider, StructureProvider>();
-        ServiceCollection.AddSingleton<ILexerProvider, LexerProvider>();
-        ServiceCollection.AddSingleton<IParserProvider, ParserProvider>();
-        ServiceCollection.AddSingleton<IParsingService, ParsingService>();
-        ServiceCollection.AddSingleton<ISourceCodeProvider, SourceCodeProvider>();
-        ServiceCollection.AddSingleton<IFileSystem, FileSystem>();
-        ServiceCollection.AddSingleton<ITextCoordinateSystemComputer, TextCoordinateSystemComputer>();
-        ServiceCollection.AddSingleton<ICodeGenService, CodeGenService>();
-
-        ServiceCollection.AddSingleton<IExecutor, Executor>();
+            .UseCommandHandler<ExecuteCommand, ExecuteCommandHandler>())
+    .UseDefaults().Build();
 
-        ServiceCollection.AddSingleton(_ => Options.Create(settings));
-
-        ServiceProvider = ServiceCollection.BuildServiceProvider();
-    }
-}
+await runner.InvokeAsync(args);