Merge pull request EvilBeaver#1576 from EvilBeaver/feature/deep-annotations

EvilBeaver · web-flow · commit 90cb7e72d37d · 2025-12-05T23:33:21.000+03:00
Аннотация как значение параметра Аннотации
diff --git a/src/OneScript.Core/Commons/Utils.cs b/src/OneScript.Core/Commons/Utils.cs
@@ -35,7 +35,20 @@ public static void ForEach<T>(this IEnumerable<T> input, Action<T> action)
                 action(data);
             }
         }
-        
+        public static string NameAndValuePresentation(string name, object value)
+        {
+            var list = new List<string>();
+            if (!string.IsNullOrEmpty(name))
+            {
+                list.Add(name);
+            }
+            if (value != null)
+            {
+                list.Add(value.ToString());
+            }
+            return string.Join("=", list);
+        }
+
         public static bool IsMonoRuntime => Type.GetType("Mono.Runtime") != null;
 
     }
diff --git a/src/OneScript.Core/Contexts/BslAnnotationAttribute.cs b/src/OneScript.Core/Contexts/BslAnnotationAttribute.cs
@@ -5,9 +5,10 @@ This Source Code Form is subject to the terms of the
 at http://mozilla.org/MPL/2.0/.
 ----------------------------------------------------------*/
 
+using OneScript.Commons;
+using OneScript.Values;
 using System;
 using System.Collections.Generic;
-using OneScript.Values;
 
 namespace OneScript.Contexts
 {
@@ -37,7 +38,7 @@ public void SetParameters(IEnumerable<BslAnnotationParameter> parameters)
 
     public class BslAnnotationParameter
     {
-        public BslAnnotationParameter(string name, BslPrimitiveValue value)
+        public BslAnnotationParameter(string name, BslPrimitiveValue value = null)
         {
             Name = name;
             Value = value;
@@ -47,6 +48,10 @@ public BslAnnotationParameter(string name, BslPrimitiveValue value)
         
         public BslPrimitiveValue Value { get; }
 
-        public int ConstantValueIndex { get; set; } = -1;
+        public override string ToString()
+        {
+            return Utils.NameAndValuePresentation(Name, Value);
+        }
+
     }
 }
diff --git a/src/OneScript.Core/Values/BslAnnotationValue.cs b/src/OneScript.Core/Values/BslAnnotationValue.cs
@@ -0,0 +1,58 @@
+﻿/*----------------------------------------------------------
+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 System;
+using OneScript.Contexts;
+using OneScript.Exceptions;
+using OneScript.Localization;
+using OneScript.Types;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OneScript.Values
+{
+    public sealed class BslAnnotationValue : BslPrimitiveValue
+    {
+        public BslAnnotationValue(string name) {
+            Name = name;
+        }
+
+        public string Name { get; }
+
+        public List<BslAnnotationParameter> Parameters { get; } = new List<BslAnnotationParameter>();
+
+        
+        public override int CompareTo(BslValue other) {
+            var msg = new BilingualString("Сравнение на больше/меньше для данного типа не поддерживается",
+                "Comparison for less/greater is not supported for this type");
+
+            throw new RuntimeException(msg);
+        }
+
+        public override bool Equals(BslValue other) {
+            return ReferenceEquals(this, other);
+        }
+
+        public override string ToString()
+        {
+            var sb = new StringBuilder("&");
+            sb.Append(Name);
+            if (Parameters.Count != 0)
+            {
+                var prefix = "(";
+                foreach (var parameter in Parameters)
+                {
+                    sb.Append(prefix);
+                    sb.Append(parameter);
+                    prefix = ",";
+                }
+                sb.Append(")");
+            }
+            return sb.ToString();
+        }
+    }
+}
diff --git a/src/OneScript.Language/SyntaxAnalysis/AstNodes/AnnotationParameterNode.cs b/src/OneScript.Language/SyntaxAnalysis/AstNodes/AnnotationParameterNode.cs
@@ -17,19 +17,29 @@ public AnnotationParameterNode() : base(NodeKind.AnnotationParameter)
         
         protected override void OnChildAdded(BslSyntaxNode child)
         {
-            var node = (TerminalNode) child;
-            if (child.Kind == NodeKind.AnnotationParameterName)
+            if (child.Kind == NodeKind.Annotation)
             {
-                Name = node.Lexem.Content;
+                AnnotationNode = (AnnotationNode)child;
             }
-            if (child.Kind == NodeKind.AnnotationParameterValue)
+            else
             {
-                Value = node.Lexem;
+                var node = (TerminalNode)child;
+                if (child.Kind == NodeKind.AnnotationParameterName)
+                {
+                    Name = node.Lexem.Content;
+                }
+                if (child.Kind == NodeKind.AnnotationParameterValue)
+                {
+                    Value = node.Lexem;
+                }
             }
         }
 
         public string Name { get; private set; }
         
         public Lexem Value { get; private set; }
+
+        public AnnotationNode AnnotationNode { get; private set; }
+
     }
 }
diff --git a/src/OneScript.Language/SyntaxAnalysis/DefaultBslParser.cs b/src/OneScript.Language/SyntaxAnalysis/DefaultBslParser.cs
@@ -541,13 +541,18 @@ private void BuildAnnotations()
         {
             while (_lastExtractedLexem.Type == LexemType.Annotation)
             {
-                var node = new AnnotationNode(NodeKind.Annotation, _lastExtractedLexem);
+                var node = BuildAnnotationDefinition();
                 _annotations.Add(node);
-                NextLexem();
-                BuildAnnotationParameters(node);
             }
         }
-        
+        private AnnotationNode BuildAnnotationDefinition() {
+            var node = new AnnotationNode(NodeKind.Annotation, _lastExtractedLexem);
+            NextLexem();
+            BuildAnnotationParameters(node);
+            return node;
+        }
+
+
         private void BuildAnnotationParameters(AnnotationNode annotation)
         {
             if (_lastExtractedLexem.Token != Token.OpenPar)
@@ -599,11 +604,16 @@ private void BuildAnnotationParameter(AnnotationNode annotation)
 
         private bool BuildAnnotationParamValue(AnnotationParameterNode annotationParam)
         {
+            if (_lastExtractedLexem.Type == LexemType.Annotation) {
+                var annotation = BuildAnnotationDefinition();
+                annotationParam.AddChild(annotation);
+                return true;
+            }
             return BuildDefaultParameterValue(annotationParam, NodeKind.AnnotationParameterValue);
         }
-        
+
         #endregion
-        
+
         private void BuildCodeBatch(params Token[] endTokens)
         {
             PushStructureToken(endTokens);
diff --git a/src/OneScript.Native/Compiler/CompilerHelpers.cs b/src/OneScript.Native/Compiler/CompilerHelpers.cs
@@ -90,6 +90,16 @@ private static IEnumerable<BslAnnotationParameter> GetAnnotationParameters(Annot
         private static BslAnnotationParameter MakeAnnotationParameter(AnnotationParameterNode param)
         {
             BslAnnotationParameter result;
+            if (param.AnnotationNode != null)
+            {
+                var runtimeValue = new BslAnnotationValue(param.AnnotationNode.Name);
+                foreach (var child in param.AnnotationNode.Children)
+                {
+                    runtimeValue.Parameters.Add(MakeAnnotationParameter((AnnotationParameterNode)child));
+                }
+                result = new BslAnnotationParameter(param.Name, runtimeValue);
+            }
+            else
             if (param.Value.Type != LexemType.NotALexem)
             {
                 var runtimeValue = ValueFromLiteral(param.Value);
diff --git a/src/OneScript.StandardLibrary/Reflector.cs b/src/OneScript.StandardLibrary/Reflector.cs
@@ -163,27 +163,41 @@ private static ValueTable CreateAnnotationTable(BslAnnotationAttribute[] annotat
                 {
                     annotationRow.Set(annotationNameColumn, ValueFactory.Create(annotation.Name));
                 }
-                var parametersTable = new ValueTable();
-                var parameterNameColumn = parametersTable.Columns.Add("Имя");
-                var parameterValueColumn = parametersTable.Columns.Add("Значение");
-
+                var parametersTable = FillAnnotationParameters(annotation.Parameters);
                 annotationRow.Set(annotationParamsColumn, parametersTable);
-                if (annotation.Parameters.Any())
-                {
+            }
 
-                    foreach (var annotationParameter in annotation.Parameters)
-                    {
-                        var parameterRow = parametersTable.Add();
-                        if (annotationParameter.Name != null)
-                        {
-                            parameterRow.Set(parameterNameColumn, ValueFactory.Create(annotationParameter.Name));
-                        }
-                        parameterRow.Set(parameterValueColumn, annotationParameter.Value);
-                    }
+            return annotationsTable;
+        }
+
+        private static ValueTable FillAnnotationParameters(IEnumerable<BslAnnotationParameter> parameters)
+        {
+            var parametersTable = new ValueTable();
+            var parameterNameColumn = parametersTable.Columns.Add("Имя");
+            var parameterValueColumn = parametersTable.Columns.Add("Значение");
+
+            foreach (var annotationParameter in parameters)
+            {
+                var parameterRow = parametersTable.Add();
+                if (annotationParameter.Name != null)
+                {
+                    parameterRow.Set(parameterNameColumn, ValueFactory.Create(annotationParameter.Name));
+                }
+                if (annotationParameter.Value is BslAnnotationValue annotationValue)
+                {
+                    var expandedValue = EmptyAnnotationsTable();
+                    var row = expandedValue.Add();
+                    row.Set(expandedValue.Columns.FindColumnByName("Имя"), ValueFactory.Create(annotationValue.Name));
+                    row.Set(expandedValue.Columns.FindColumnByName("Параметры"), FillAnnotationParameters(annotationValue.Parameters));
+                    parameterRow.Set(parameterValueColumn, row);
+                }
+                else
+                {
+                    parameterRow.Set(parameterValueColumn, annotationParameter.Value);
                 }
             }
 
-            return annotationsTable;
+           return parametersTable;
         }
 
         private static bool MethodExistsForType(BslTypeValue type, string methodName)
diff --git a/src/ScriptEngine/Compiler/StackMachineCodeGenerator.cs b/src/ScriptEngine/Compiler/StackMachineCodeGenerator.cs
@@ -12,6 +12,7 @@ This Source Code Form is subject to the terms of the
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Text;
 using OneScript.Compilation;
 using OneScript.Compilation.Binding;
 using OneScript.Contexts;
@@ -1237,23 +1238,35 @@ private IEnumerable<BslAnnotationParameter> GetAnnotationParameters(AnnotationNo
 
         private BslAnnotationParameter MakeAnnotationParameter(AnnotationParameterNode param)
         {
-            BslAnnotationParameter result;
+            var runtimeValue = MakeAnnotationParameterValueConstant(param);
+            return new BslAnnotationParameter(param.Name, runtimeValue);
+        }
+
+        private BslPrimitiveValue MakeAnnotationParameterValueConstant(AnnotationParameterNode param)
+        {
+            if (param.AnnotationNode != null)
+            {
+                var runtimeValue = new BslAnnotationValue(param.AnnotationNode.Name);
+                foreach (var child in param.AnnotationNode.Children)
+                {
+                    var parameter = (AnnotationParameterNode)child;
+                    var parameterValue = MakeAnnotationParameterValueConstant(parameter);
+                    runtimeValue.Parameters.Add(new BslAnnotationParameter(parameter.Name, parameterValue));
+                }
+                return runtimeValue;
+            }
+            else
             if (param.Value.Type != LexemType.NotALexem)
             {
                 var constDef = CreateConstDefinition(param.Value);
                 var constNumber = GetConstNumber(constDef);
                 var runtimeValue = _module.Constants[constNumber];
-                result = new BslAnnotationParameter(param.Name, runtimeValue)
-                {
-                    ConstantValueIndex = constNumber
-                };
+                return runtimeValue;
             }
             else
             {
-                result = new BslAnnotationParameter(param.Name, null);
+                return null;
             }
-
-            return result;
         }
 
         private IEnumerable<BslAnnotationAttribute> GetAnnotations(AnnotatableNode parent)
@@ -1302,7 +1315,7 @@ private static ConstDefinition CreateConstDefinition(in Lexem lex)
             };
             return cDef;
         }
-        
+
         private int GetConstNumber(in ConstDefinition cDef)
         {
             var idx = _constMap.IndexOf(cDef);
diff --git a/src/ScriptEngine/Machine/AnnotationDefinition.cs b/src/ScriptEngine/Machine/AnnotationDefinition.cs
@@ -0,0 +1,17 @@
+﻿/*----------------------------------------------------------
+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 System;
+
+namespace ScriptEngine.Machine
+{
+    public struct AnnotationDefinition
+    {
+        public string Name;
+        public AnnotationParameter[] Parameters;
+        public readonly int ParamCount => Parameters?.Length ?? 0;
+    }
+}
diff --git a/src/ScriptEngine/Machine/AnnotationParameter.cs b/src/ScriptEngine/Machine/AnnotationParameter.cs
@@ -0,0 +1,23 @@
+﻿/*----------------------------------------------------------
+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 OneScript.Commons;
+
+namespace ScriptEngine.Machine
+{
+    public struct AnnotationParameter
+    {
+        public string Name;
+
+        public IValue RuntimeValue;
+
+        public override readonly string ToString()
+        {
+            return Utils.NameAndValuePresentation(Name, RuntimeValue);
+        }
+
+    }
+}
diff --git a/src/ScriptEngine/Machine/Core.cs b/src/ScriptEngine/Machine/Core.cs
diff --git a/src/ScriptEngine/Machine/StackRuntimeAdoptionExtensions.cs b/src/ScriptEngine/Machine/StackRuntimeAdoptionExtensions.cs
diff --git a/src/Tests/OneScript.Core.Tests/CodeGenerationTests.cs b/src/Tests/OneScript.Core.Tests/CodeGenerationTests.cs
diff --git a/src/Tests/OneScript.Language.Tests/ParserTests.cs b/src/Tests/OneScript.Language.Tests/ParserTests.cs
diff --git a/tests/annotations.os b/tests/annotations.os

Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,10 @@ This Source Code Form is subject to the terms of the`
`5`	`5`	`at http://mozilla.org/MPL/2.0/.`
`6`	`6`	`----------------------------------------------------------*/`
`7`	`7`
	`8`	`+using OneScript.Commons;`
	`9`	`+using OneScript.Values;`
`8`	`10`	`using System;`
`9`	`11`	`using System.Collections.Generic;`
`10`		`-using OneScript.Values;`
`11`	`12`
`12`	`13`	`namespace OneScript.Contexts`
`13`	`14`	`{`
`@@ -37,7 +38,7 @@ public void SetParameters(IEnumerable<BslAnnotationParameter> parameters)`
`37`	`38`
`38`	`39`	`public class BslAnnotationParameter`
`39`	`40`	`{`
`40`		`- public BslAnnotationParameter(string name, BslPrimitiveValue value)`
	`41`	`+ public BslAnnotationParameter(string name, BslPrimitiveValue value = null)`
`41`	`42`	`{`
`42`	`43`	`Name = name;`
`43`	`44`	`Value = value;`
`@@ -47,6 +48,10 @@ public BslAnnotationParameter(string name, BslPrimitiveValue value)`
`47`	`48`
`48`	`49`	`public BslPrimitiveValue Value { get; }`
`49`	`50`
`50`		`- public int ConstantValueIndex { get; set; } = -1;`
	`51`	`+ public override string ToString()`
	`52`	`+ {`
	`53`	`+ return Utils.NameAndValuePresentation(Name, Value);`
	`54`	`+ }`
	`55`	`+`
`51`	`56`	`}`
`52`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,19 +17,29 @@ public AnnotationParameterNode() : base(NodeKind.AnnotationParameter)`
`17`	`17`
`18`	`18`	`protected override void OnChildAdded(BslSyntaxNode child)`
`19`	`19`	`{`
`20`		`- var node = (TerminalNode) child;`
`21`		`- if (child.Kind == NodeKind.AnnotationParameterName)`
	`20`	`+ if (child.Kind == NodeKind.Annotation)`
`22`	`21`	`{`
`23`		`- Name = node.Lexem.Content;`
	`22`	`+ AnnotationNode = (AnnotationNode)child;`
`24`	`23`	`}`
`25`		`- if (child.Kind == NodeKind.AnnotationParameterValue)`
	`24`	`+ else`
`26`	`25`	`{`
`27`		`- Value = node.Lexem;`
	`26`	`+ var node = (TerminalNode)child;`
	`27`	`+ if (child.Kind == NodeKind.AnnotationParameterName)`
	`28`	`+ {`
	`29`	`+ Name = node.Lexem.Content;`
	`30`	`+ }`
	`31`	`+ if (child.Kind == NodeKind.AnnotationParameterValue)`
	`32`	`+ {`
	`33`	`+ Value = node.Lexem;`
	`34`	`+ }`
`28`	`35`	`}`
`29`	`36`	`}`
`30`	`37`
`31`	`38`	`public string Name { get; private set; }`
`32`	`39`
`33`	`40`	`public Lexem Value { get; private set; }`
	`41`	`+`
	`42`	`+ public AnnotationNode AnnotationNode { get; private set; }`
	`43`	`+`
`34`	`44`	`}`
`35`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -541,13 +541,18 @@ private void BuildAnnotations()`
`541`	`541`	`{`
`542`	`542`	`while (_lastExtractedLexem.Type == LexemType.Annotation)`
`543`	`543`	`{`
`544`		`- var node = new AnnotationNode(NodeKind.Annotation, _lastExtractedLexem);`
	`544`	`+ var node = BuildAnnotationDefinition();`
`545`	`545`	`_annotations.Add(node);`
`546`		`- NextLexem();`
`547`		`- BuildAnnotationParameters(node);`
`548`	`546`	`}`
`549`	`547`	`}`
`550`		`-`
	`548`	`+ private AnnotationNode BuildAnnotationDefinition() {`
	`549`	`+ var node = new AnnotationNode(NodeKind.Annotation, _lastExtractedLexem);`
	`550`	`+ NextLexem();`
	`551`	`+ BuildAnnotationParameters(node);`
	`552`	`+ return node;`
	`553`	`+ }`
	`554`	`+`
	`555`	`+`
`551`	`556`	`private void BuildAnnotationParameters(AnnotationNode annotation)`
`552`	`557`	`{`
`553`	`558`	`if (_lastExtractedLexem.Token != Token.OpenPar)`
`@@ -599,11 +604,16 @@ private void BuildAnnotationParameter(AnnotationNode annotation)`
`599`	`604`
`600`	`605`	`private bool BuildAnnotationParamValue(AnnotationParameterNode annotationParam)`
`601`	`606`	`{`
	`607`	`+ if (_lastExtractedLexem.Type == LexemType.Annotation) {`
	`608`	`+ var annotation = BuildAnnotationDefinition();`
	`609`	`+ annotationParam.AddChild(annotation);`
	`610`	`+ return true;`
	`611`	`+ }`
`602`	`612`	`return BuildDefaultParameterValue(annotationParam, NodeKind.AnnotationParameterValue);`
`603`	`613`	`}`
`604`		`-`
	`614`	`+`
`605`	`615`	`#endregion`
`606`		`-`
	`616`	`+`
`607`	`617`	`private void BuildCodeBatch(params Token[] endTokens)`
`608`	`618`	`{`
`609`	`619`	`PushStructureToken(endTokens);`