Аннотация как значение параметра Аннотации

src/OneScript.Core/Contexts/BslAnnotationAttribute.cs

@@ -37,7 +37,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 +47,5 @@ public BslAnnotationParameter(string name, BslPrimitiveValue value)
 
         public BslPrimitiveValue Value { get; }
 
-        public int ConstantValueIndex { get; set; } = -1;
     }
 }

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();
+        }
+    }
+}

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; }
+
     }
 }

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);

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);

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)

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;
@@ -1170,22 +1171,41 @@ 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));
+                }
+                var constNumber = CreateAnnotationConstDefinition(runtimeValue);
+                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;
             }
+        }
 
+        private int CreateAnnotationConstDefinition(BslAnnotationValue runtimeValue)
+        {
+            var result = RegisterAnnotationConst(runtimeValue);
             return result;
         }
 
@@ -1235,7 +1255,7 @@ private static ConstDefinition CreateConstDefinition(in Lexem lex)
             };
             return cDef;
         }
-        
+
         private int GetConstNumber(in ConstDefinition cDef)
         {
             var idx = _constMap.IndexOf(cDef);
@@ -1248,6 +1268,13 @@ private int GetConstNumber(in ConstDefinition cDef)
             return idx;
         }
 
+        private int RegisterAnnotationConst(BslAnnotationValue value)
+        {
+            var idx = _module.AnnotationValues.Count;
+            _module.AnnotationValues.Add(value);
+            return idx;
+        }
+
         private int GetMethodRefNumber(in SymbolBinding methodBinding)
         {
             var idx = _module.MethodRefs.IndexOf(methodBinding);

src/ScriptEngine/Machine/AnnotationDefinition.cs

@@ -0,0 +1,20 @@
+/*----------------------------------------------------------
+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 System.Text;
+
+namespace ScriptEngine.Machine
+{
+    [Serializable]
+    public struct AnnotationDefinition
+    {
+        public string Name;
+        public AnnotationParameter[] Parameters;
+
+        public int ParamCount => Parameters?.Length ?? 0;
+    }
+}

src/ScriptEngine/Machine/AnnotationParameter.cs

@@ -0,0 +1,37 @@
+/*----------------------------------------------------------
+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 System.Collections.Generic;
+
+namespace ScriptEngine.Machine
+{
+    [Serializable]
+    public struct AnnotationParameter
+    {
+        public string Name;
+
+        [NonSerialized]
+        public IValue RuntimeValue;
+
+        public const int UNDEFINED_VALUE_INDEX = -1;
+
+
+        public override string ToString()
+        {
+            var list = new List<string>();
+            if (!string.IsNullOrEmpty(Name))
+            {
+                list.Add(Name);
+            }
+            if (RuntimeValue != null)
+            {
+                list.Add(RuntimeValue.ToString());
+            }
+            return string.Join("=", list);
+        }
+    }
+}