update system methods.

src/Neo.Compiler.CSharp/MethodConvert/ConstructorConvert.cs

@@ -28,11 +28,11 @@ private void ProcessFields(SemanticModel model)
         {
             ProcessFieldInitializer(model, fields[i], () =>
             {
-                AddInstruction(OpCode.LDARG0);
-                Push(i);
+                _instructionsBuilder.LdArg0();
+                _instructionsBuilder.Push(i);
             }, () =>
             {
-                AddInstruction(OpCode.SETITEM);
+                _instructionsBuilder.SetItem();
             });
         }
     }
@@ -61,36 +61,35 @@ private void ProcessConstructorInitializer(SemanticModel model)
 
     private void ProcessStaticFields(SemanticModel model)
     {
-        foreach (INamedTypeSymbol @class in _context.StaticFieldSymbols.Select(p => p.ContainingType).Distinct<INamedTypeSymbol>(SymbolEqualityComparer.Default).ToArray())
+        foreach (INamedTypeSymbol @class in Context.StaticFieldSymbols.Select(p => p.ContainingType).Distinct<INamedTypeSymbol>(SymbolEqualityComparer.Default).ToArray())
         {
             foreach (IFieldSymbol field in @class.GetAllMembers().OfType<IFieldSymbol>())
             {
                 if (field.IsConst || !field.IsStatic) continue;
                 ProcessFieldInitializer(model, field, null, () =>
                 {
-                    byte index = _context.AddStaticField(field);
-                    AccessSlot(OpCode.STSFLD, index);
+                    byte index = Context.AddStaticField(field);
+                    _instructionsBuilder.StSFld(index);
                 });
             }
         }
-        foreach (var (fieldIndex, type) in _context.VTables)
+        foreach (var (fieldIndex, type) in Context.VTables)
         {
             IMethodSymbol[] virtualMethods = type.GetAllMembers().OfType<IMethodSymbol>().Where(p => p.IsVirtualMethod()).ToArray();
             for (int i = virtualMethods.Length - 1; i >= 0; i--)
             {
                 IMethodSymbol method = virtualMethods[i];
                 if (method.IsAbstract)
                 {
-                    Push((object?)null);
+                    _instructionsBuilder.Push((object?)null);
                 }
                 else
                 {
                     InvokeMethod(model, method);
                 }
             }
-            Push(virtualMethods.Length);
-            AddInstruction(OpCode.PACK);
-            AccessSlot(OpCode.STSFLD, fieldIndex);
+            _instructionsBuilder.Pack(virtualMethods.Length);
+            _instructionsBuilder.StSFld(fieldIndex);
         }
     }
 }

src/Neo.Compiler.CSharp/MethodConvert/Expression/AnonymousObjectCreationExpression.cs

@@ -35,12 +35,12 @@ internal partial class MethodConvert
     /// <seealso href="https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/anonymous-types">Anonymous types</seealso>
     private void ConvertAnonymousObjectCreationExpression(SemanticModel model, AnonymousObjectCreationExpressionSyntax expression)
     {
-        AddInstruction(OpCode.NEWARRAY0);
+        _instructionsBuilder.NewArray0();
         foreach (AnonymousObjectMemberDeclaratorSyntax initializer in expression.Initializers)
         {
-            AddInstruction(OpCode.DUP);
+            _instructionsBuilder.Dup();
             ConvertExpression(model, initializer.Expression);
-            AddInstruction(OpCode.APPEND);
+            _instructionsBuilder.Append();
         }
     }
 }

src/Neo.Compiler.CSharp/MethodConvert/Expression/ArrayCreationExpression.cs

@@ -48,9 +48,9 @@ private void ConvertArrayCreationExpression(SemanticModel model, ArrayCreationEx
         {
             ConvertExpression(model, specifier.Sizes[0]);
             if (type.ElementType.SpecialType == SpecialType.System_Byte)
-                AddInstruction(OpCode.NEWBUFFER);
+                _instructionsBuilder.NewBuffer();
             else
-                AddInstruction(new Instruction { OpCode = OpCode.NEWARRAY_T, Operand = new[] { (byte)type.ElementType.GetStackItemType() } });
+                _instructionsBuilder.AddInstruction(new Instruction { OpCode = OpCode.NEWARRAY_T, Operand = new[] { (byte)type.ElementType.GetStackItemType() } });
         }
         else
         {