[SysCall] add support to enum methods,

src/Neo.Compiler.CSharp/Diagnostic/DiagnosticId.cs

@@ -36,5 +36,7 @@ static class DiagnosticId
         public const string InvalidInitialValue = "NC3005";
         public const string IncorrectNEPStandard = "NC3006";
         public const string CapturedStaticFieldNotFound = "NC3007";
+        public const string InvalidType = "NC3008";
+        public const string InvalidArgument = "NC3009";
     }
 }

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

@@ -56,7 +56,7 @@
 
         if (typeSymbol != null)
         {
             value = ConvertComplexConstantTypes(typeSymbol, value, syntax);
         }
 
         Push(value);
@@ -192,11 +192,27 @@
                 // Example: 42 or "Hello"
                 ConvertLiteralExpression(model, expression);
                 break;
+            case TypeOfExpressionSyntax expression:
+                // Example: typeof(int)
+                // Note: Neo currently does not support the Type type of C#. The typeof operator here
+                // will only return the string name of the class/type. This support is added
+                // to ensure we can process enum parse methods.
+                ConvertTypeOfExpression(model, expression);
+                break;
             default:
                 throw new CompilationException(syntax, DiagnosticId.SyntaxNotSupported, $"Unsupported syntax: {syntax}");
         }
     }
 
+    private void ConvertTypeOfExpression(SemanticModel model, TypeOfExpressionSyntax expression)
+    {
+        var typeInfo = model.GetTypeInfo(expression.Type);
+        if (typeInfo.Type == null)
+            throw new CompilationException(expression, DiagnosticId.InvalidType, $"Invalid type in typeof expression: {expression.Type}");
+
+        Push(typeInfo.Type.Name);
+    }
+
     private static ITypeSymbol? GetTypeSymbol(SyntaxNode? syntaxNode, SemanticModel model)
     {
         return syntaxNode switch

src/Neo.Compiler.CSharp/MethodConvert/Helpers/StackHelpers.cs

@@ -68,6 +68,8 @@ private void Push(bool value)
         AddInstruction(value ? OpCode.PUSHT : OpCode.PUSHF);
     }
 
+    private Instruction Ret() => AddInstruction(OpCode.RET);
+
     private Instruction Push(BigInteger number)
     {
         if (number >= -1 && number <= 16) return AddInstruction(number == -1 ? OpCode.PUSHM1 : OpCode.PUSH0 + (byte)(int)number);

src/Neo.Compiler.CSharp/MethodConvert/StackHelpers.OpCodes.cs

@@ -541,5 +541,16 @@ private Instruction Assertmsg()
     {
         return AddInstruction(OpCode.ASSERTMSG);
     }
+
+    private Instruction JumpIfNot(JumpTarget target)
+    {
+        return Jump(OpCode.JMPIFNOT, target);
+    }
+
+    private Instruction Jump(JumpTarget target)
+    {
+        return Jump(OpCode.JMP, target);
+    }
+
     #endregion
 }