Add missing Copy logic for Array element values.

Author: wasabii

src/IKVM.ByteCode/Decoding/ArrayElementValue.cs

@@ -3,6 +3,8 @@
 using System.Collections;
 using System.Collections.Generic;
 
+using IKVM.ByteCode.Encoding;
+
 namespace IKVM.ByteCode.Decoding
 {
 
@@ -121,6 +123,78 @@ public static bool TryRead(ref ClassFormatReader reader, out ArrayElementValue v
             return true;
         }
 
+        /// <summary>
+        /// Copies this annotation to the encoder.
+        /// </summary>
+        /// <typeparam name="TConstantView"></typeparam>
+        /// <typeparam name="TConstantPool"></typeparam>
+        /// <param name="constantView"></param>
+        /// <param name="constantPool"></param>
+        /// <param name="encoder"></param>
+        public readonly void CopyTo<TConstantView, TConstantPool>(TConstantView constantView, TConstantPool constantPool, ref ElementValueTableEncoder encoder)
+            where TConstantView : IConstantView
+            where TConstantPool : IConstantPool
+        {
+            foreach (var i in this)
+            {
+                switch (i.Kind)
+                {
+                    case ElementValueKind.Byte:
+                        var _byte = i.AsConstant();
+                        encoder.Byte(constantPool.Get(constantView.Get((IntegerConstantHandle)_byte.Handle)));
+                        break;
+                    case ElementValueKind.Char:
+                        var _char = i.AsConstant();
+                        encoder.Char(constantPool.Get(constantView.Get((IntegerConstantHandle)_char.Handle)));
+                        break;
+                    case ElementValueKind.Double:
+                        var _double = i.AsConstant();
+                        encoder.Double(constantPool.Get(constantView.Get((DoubleConstantHandle)_double.Handle)));
+                        break;
+                    case ElementValueKind.Float:
+                        var _float = i.AsConstant();
+                        encoder.Float(constantPool.Get(constantView.Get((FloatConstantHandle)_float.Handle)));
+                        break;
+                    case ElementValueKind.Integer:
+                        var _integer = i.AsConstant();
+                        encoder.Integer(constantPool.Get(constantView.Get((IntegerConstantHandle)_integer.Handle)));
+                        break;
+                    case ElementValueKind.Long:
+                        var _long = i.AsConstant();
+                        encoder.Long(constantPool.Get(constantView.Get((LongConstantHandle)_long.Handle)));
+                        break;
+                    case ElementValueKind.Short:
+                        var _short = i.AsConstant();
+                        encoder.Short(constantPool.Get(constantView.Get((IntegerConstantHandle)_short.Handle)));
+                        break;
+                    case ElementValueKind.Boolean:
+                        var _boolean = i.AsConstant();
+                        encoder.Boolean(constantPool.Get(constantView.Get((IntegerConstantHandle)_boolean.Handle)));
+                        break;
+                    case ElementValueKind.String:
+                        var _string = i.AsConstant();
+                        encoder.String(constantPool.Get(constantView.Get((Utf8ConstantHandle)_string.Handle)));
+                        break;
+                    case ElementValueKind.Enum:
+                        var _enum = i.AsEnum();
+                        encoder.Enum(constantPool.Get(constantView.Get(_enum.TypeName)), constantPool.Get(constantView.Get(_enum.ConstantName)));
+                        break;
+                    case ElementValueKind.Class:
+                        var _class = i.AsClass();
+                        encoder.Class(constantPool.Get(constantView.Get(_class.Class)));
+                        break;
+                    case ElementValueKind.Annotation:
+                        var _annotation = i.AsAnnotation();
+                        encoder.Annotation(e => _annotation.Annotation.CopyTo(constantView, constantPool, ref e));
+                        break;
+                    case ElementValueKind.Array:
+                        var _array = i.AsArray();
+                        encoder.Array(e => _array.CopyTo(constantView, constantPool, ref e));
+                        break;
+                }
+            }
+        }
+
         readonly ElementValue[] _items;
         readonly bool _isNotNil = true;
 

src/IKVM.ByteCode/Decoding/ElementValue.cs

@@ -229,7 +229,8 @@ public readonly ArrayElementValue AsArray()
         /// <summary>
         /// Encodes this data class to the encoder.
         /// </summary>
-        /// <param name="map"></param>
+        /// <param name="constantView"></param>
+        /// <param name="constantPool"></param>
         /// <param name="encoder"></param>
         public readonly void CopyTo<TConstantView, TConstantPool>(TConstantView constantView, TConstantPool constantPool, ref ElementValueEncoder encoder)
             where TConstantView : IConstantView
@@ -286,6 +287,8 @@ public readonly void CopyTo<TConstantView, TConstantPool>(TConstantView constant
                     encoder.Annotation(e => _annotation.Annotation.CopyTo(constantView, constantPool, ref e));
                     break;
                 case ElementValueKind.Array:
+                    var _array = AsArray();
+                    encoder.Array(e => _array.CopyTo(constantView, constantPool, ref e));
                     break;
             }
         }

src/IKVM.ByteCode/Encoding/ElementValueEncoder.cs

@@ -193,7 +193,7 @@ public void Class(Utf8ConstantHandle classInfo)
         /// <summary>
         /// Denotes a "nested" annotation as the value of this element-value pair.
         /// </summary>
-        /// <param name="annotations"></param>
+        /// <param name="annotationValue"></param>
         public void Annotation(Action<AnnotationEncoder> annotationValue)
         {
             if (_count > 0)

src/IKVM.ByteCode/Encoding/ElementValueTableEncoder.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 
 using IKVM.ByteCode.Buffers;
 
@@ -150,6 +149,15 @@ public ElementValueTableEncoder Annotation(Action<AnnotationEncoder> annotationV
             return ElementValue(e => e.Annotation(annotationValue));
         }
 
+        /// <summary>
+        /// Denotes a "nested" annotation as the value of this element-value pair.
+        /// </summary>
+        /// <param name="array"></param>
+        public ElementValueTableEncoder Array(Action<ElementValueTableEncoder> array)
+        {
+            return ElementValue(e => e.Array(array));
+        }
+
     }
 
 }