fixed #1696 Разрешалось чередование режимов компиляции в одном модуле

Author: EvilBeaver

src/OneScript.Language/SyntaxAnalysis/LocalizedErrors.cs

@@ -137,6 +137,10 @@ public static CodeError InvalidRegionName(string name) =>
         public static CodeError DirectiveIsMissing(string directive) =>
             Create($"Пропущена директива #{directive}", $"Directive #{directive} is missing");
 
+        public static CodeError RuntimeDirectiveAlreadyDefined() =>
+            Create("Директива режима выполнения (#native или #stack) может быть указана только один раз",
+                "Runtime directive (#native or #stack) can be specified only once");
+
         public static CodeError LibraryNameExpected() =>
             Create("Ожидается имя библиотеки", "Library name expected");
 

src/OneScript.Native/Compiler/NativeRuntimeAnnotationHandler.cs

@@ -7,6 +7,7 @@ This Source Code Form is subject to the terms of the
 
 using System.Collections.Generic;
 using OneScript.Language;
+using OneScript.Language.LexicalAnalysis;
 using OneScript.Language.SyntaxAnalysis;
 
 namespace OneScript.Native.Compiler
@@ -21,9 +22,47 @@ public class NativeRuntimeAnnotationHandler : SingleWordModuleAnnotationHandler
             NativeDirectiveName,
             StackRuntimeDirectiveName
         };
+
+        private bool _runtimeDirectiveDefined;
 
         public NativeRuntimeAnnotationHandler(IErrorSink errorSink) : base(Directives, errorSink)
         {
         }
+
+        public override void OnModuleEnter()
+        {
+            _runtimeDirectiveDefined = false;
+            base.OnModuleEnter();
+        }
+
+        public override void OnModuleLeave()
+        {
+            _runtimeDirectiveDefined = false;
+            base.OnModuleLeave();
+        }
+
+        protected override void ParseAnnotationInternal(
+            ref Lexem lastExtractedLexem,
+            ILexer lexer,
+            ParserContext parserContext)
+        {
+            if (_runtimeDirectiveDefined)
+            {
+                var err = LocalizedErrors.RuntimeDirectiveAlreadyDefined();
+                err.Position = new ErrorPositionInfo
+                {
+                    LineNumber = lastExtractedLexem.Location.LineNumber,
+                    ColumnNumber = lastExtractedLexem.Location.ColumnNumber,
+                    Code = lexer.Iterator.GetCodeLine(lastExtractedLexem.Location.LineNumber),
+                    ModuleName = lexer.Iterator.Source.Name
+                };
+                ErrorSink.AddError(err);
+                lastExtractedLexem = lexer.NextLexem();
+                return;
+            }
+
+            _runtimeDirectiveDefined = true;
+            base.ParseAnnotationInternal(ref lastExtractedLexem, lexer, parserContext);
+        }
     }
-}
+}

src/Tests/OneScript.Dynamic.Tests/NativeRuntimeAnnotationHandlerTests.cs

@@ -0,0 +1,89 @@
+/*----------------------------------------------------------
+This Source Code Form is subject to the terms of the
+Mozilla Public License, v.2.0. If a copy of the MPL
+was not distributed with this file, You can obtain one
+at http://mozilla.org/MPL/2.0/.
+----------------------------------------------------------*/
+
+using FluentAssertions;
+using OneScript.Compilation;
+using OneScript.Language;
+using OneScript.Language.LexicalAnalysis;
+using OneScript.Language.SyntaxAnalysis;
+using OneScript.Native.Compiler;
+using OneScript.Sources;
+using Xunit;
+
+namespace OneScript.Dynamic.Tests
+{
+    public class NativeRuntimeAnnotationHandlerTests
+    {
+        [Theory]
+        [InlineData("#stack\n#native")]
+        [InlineData("#native\n#stack")]
+        [InlineData("#stack\n#stack")]
+        [InlineData("#native\n#native")]
+        public void Duplicate_Runtime_Directive_Should_Report_Error(string code)
+        {
+            var errors = ParseModule(code);
+
+            errors.Should().ContainSingle(e => e.ErrorId == "RuntimeDirectiveAlreadyDefined");
+        }
+
+        [Theory]
+        [InlineData("#native")]
+        [InlineData("#stack")]
+        public void Single_Runtime_Directive_Should_Parse(string code)
+        {
+            var errors = ParseModule(code);
+
+            errors.Should().BeEmpty();
+        }
+
+        [Fact]
+        public void Duplicate_Runtime_Directive_Should_Throw_CompilerException()
+        {
+            var code = "#stack\n#native";
+
+            var act = () => ParseModuleWithThrowingSink(code);
+
+            act.Should().Throw<CompilerException>()
+                .Which.LineNumber.Should().Be(2);
+        }
+
+        private static System.Collections.Generic.IEnumerable<CodeError> ParseModule(string code)
+        {
+            var errors = new ListErrorSink();
+            Parse(code, errors);
+            return errors.Errors;
+        }
+
+        private static void ParseModuleWithThrowingSink(string code)
+        {
+            var errors = new ThrowingErrorSink(CompilerException.FromCodeError);
+            Parse(code, errors);
+        }
+
+        private static void Parse(string code, IErrorSink errors)
+        {
+            var lexer = new DefaultLexer
+            {
+                Iterator = SourceCodeBuilder.Create()
+                    .FromString(code)
+                    .WithName("<text>")
+                    .Build()
+                    .CreateIterator()
+            };
+
+            var handlers = new PreprocessorHandlers(new[] { new NativeRuntimeAnnotationHandler(errors) });
+            var preprocessingLexer = new PreprocessingLexer(lexer)
+            {
+                Handlers = handlers,
+                ErrorSink = errors
+            };
+
+            var parser = new DefaultBslParser(preprocessingLexer, errors, handlers);
+            _ = parser.ParseStatefulModule();
+        }
+    }
+}