Add ContractCall and UTs, delete Appcall

src/Neo.Compiler.MSIL/MSIL/Conv_Multi.cs

@@ -162,17 +162,17 @@ public bool IsSysCall(Mono.Cecil.MethodDefinition defs, out string name)
                 }
         */
 
-        public bool IsAppCall(Mono.Cecil.MethodDefinition defs, out byte[] hash)
+        public bool IsContractCall(Mono.Cecil.MethodDefinition defs, out byte[] hash)
         {
             if (defs == null)
             {
                 hash = null;
                 return false;
             }
 
-            foreach (var attr in defs.CustomAttributes)
+            foreach (var attr in defs.DeclaringType.CustomAttributes)
             {
-                if (attr.AttributeType.Name == "AppcallAttribute")
+                if (attr.AttributeType.Name == "ContractAttribute")
                 {
                     var type = attr.ConstructorArguments[0].Type;
                     var a = attr.ConstructorArguments[0];
@@ -462,16 +462,18 @@ private int ConvertCall(OpCode src, NeoMethod to)
                     calltype = 2;
                 }
             }
-            else if (IsAppCall(defs, out callhash))
+            else if (IsContractCall(defs, out callhash))
             {
                 calltype = 4;
             }
             else if (this.outModule.mapMethods.ContainsKey(src.tokenMethod))
-            {//this is a call
+            {
+                //this is a call
                 calltype = 1;
             }
             else
-            {//maybe a syscall // or other
+            {
+                //maybe a syscall // or other
                 if (src.tokenMethod.Contains("::op_Explicit(") || src.tokenMethod.Contains("::op_Implicit("))
                 {
                     //All types of display implicit conversion are ignored
@@ -738,7 +740,8 @@ private int ConvertCall(OpCode src, NeoMethod to)
                 //opcode call
             }
             else
-            {// reverse the arguments order
+            {
+                // reverse the arguments order
 
                 //this become very diffcult
 
@@ -829,8 +832,21 @@ private int ConvertCall(OpCode src, NeoMethod to)
             }
             else if (calltype == 4)
             {
+                // Package the arguments into an array.
+                ConvertPushNumber(pcount, null, to);
+                Convert1by1(VM.OpCode.PACK, null, to);
+
+                // Push call method name, the first letter should be lowercase.
+                var methodName = defs.Body.Method.Name;
+                ConvertPushString(methodName[..1].ToLowerInvariant() + methodName[1..], src, to);
+
+                // Push contract hash.
                 ConvertPushDataArray(callhash, src, to);
                 Insert1(VM.OpCode.SYSCALL, "", to, BitConverter.GetBytes(ApplicationEngine.System_Contract_Call));
+
+                // If the return type is void, insert a DROP.
+                if (defs.ReturnType.FullName is "System.Void")
+                    Insert1(VM.OpCode.DROP, "", to);
             }
             else if (calltype == 5)
             {

src/Neo.Compiler.MSIL/MSIL/Converter.cs

@@ -109,7 +109,7 @@ public NeoModule Convert(ILModule _in, ConvOption option = null)
                             nm.paramtypes.Add(new NeoParam(src.name, src.type));
                         }
 
-                        if (IsAppCall(m.Value.method, out byte[] outcall))
+                        if (IsContractCall(m.Value.method, out byte[] outcall))
                             continue;
                         if (IsNonCall(m.Value.method))
                             continue;

src/Neo.SmartContract.Framework/ContractAttribute.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Globalization;
+
+namespace Neo.SmartContract.Framework
+{
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public class ContractAttribute : Attribute
+    {
+        public byte[] Hash { get; }
+
+        public ContractAttribute(byte[] hash)
+        {
+            if (hash == null) throw new ArgumentNullException();
+            if (hash.Length != 20) throw new ArgumentException();
+            Hash = hash;
+        }
+
+        public ContractAttribute(string hash)
+        {
+            if (hash == null) throw new ArgumentNullException();
+
+            if (hash.StartsWith("0x"))
+            {
+                hash = hash.Remove(0, 2);
+            }
+
+            if (hash.Length != 40) throw new ArgumentException();
+            Hash = new byte[hash.Length / 2];
+            for (int i = 0; i < Hash.Length; i++)
+                Hash[i] = byte.Parse(hash.Substring(i * 2, 2), NumberStyles.AllowHexSpecifier);
+        }
+    }
+}

src/Neo.SmartContract.Framework/Services/Neo/GAS.cs

@@ -0,0 +1,16 @@
+#pragma warning disable CS0626
+
+using System.Numerics;
+
+namespace Neo.SmartContract.Framework.Services.Neo
+{
+    [Contract("0x668e0c1f9d7b70a99dd9e06eadd4c784d641afbc")]
+    public class GAS
+    {
+        public static extern string Name();
+        public static extern string Symbol();
+        public static extern byte Decimals();
+        public static extern BigInteger TotalSupply();
+        public static extern BigInteger BalanceOf(byte[] account);
+    }
+}

src/Neo.SmartContract.Framework/Services/Neo/NEO.cs

@@ -0,0 +1,26 @@
+#pragma warning disable CS0626
+
+using System.Numerics;
+
+namespace Neo.SmartContract.Framework.Services.Neo
+{
+    [Contract("0xde5f57d430d3dece511cf975a8d37848cb9e0525")]
+    public class NEO
+    {
+        public static extern string Name();
+        public static extern string Symbol();
+        public static extern byte Decimals();
+        public static extern BigInteger TotalSupply();
+        public static extern BigInteger BalanceOf(byte[] account);
+
+        public static extern BigInteger UnclaimedGas(byte[] account, uint end);
+
+        public static extern bool RegisterCandidate(byte[] pubkey);
+        public static extern bool UnRegisterCandidate(byte[] pubkey);
+        public static extern bool Vote(byte[] account, byte[] voteTo);
+        public static extern object GetCandidates();
+        public static extern object GetValidators();
+        public static extern object GetCommittee();
+        public static extern object GetNextBlockValidators();
+    }
+}

src/Neo.SmartContract.Framework/Services/Neo/Policy.cs

@@ -0,0 +1,23 @@
+#pragma warning disable CS0626
+
+using System.Numerics;
+
+namespace Neo.SmartContract.Framework.Services.Neo
+{
+    [Contract("0xce06595079cd69583126dbfd1d2e25cca74cffe9")]
+    public class Policy
+    {
+        public static extern string Name();
+        public static extern uint GetMaxTransactionsPerBlock();
+        public static extern uint GetMaxBlockSize();
+        public static extern long GetMaxBlockSystemFee();
+        public static extern BigInteger GetFeePerByte();
+        public static extern object GetBlockedAccounts();
+        public static extern bool SetMaxBlockSize(uint value);
+        public static extern bool SetMaxTransactionsPerBlock(uint value);
+        public static extern bool SetMaxBlockSystemFee(long value);
+        public static extern bool SetFeePerByte(long value);
+        public static extern bool BlockAccount(byte[] account);
+        public static extern bool UnblockAccount(byte[] account);
+    }
+}

tests/Neo.Compiler.MSIL.UnitTests/TestClasses/Contract1.cs

@@ -8,5 +8,16 @@ public static byte[] unitTest_001()
             return nb;
         }
 
+        public static void testVoid()
+        {
+            var nb = new byte[] { 1, 2, 3, 4 };
+        }
+
+        public static byte[] testArgs(byte a)
+        {
+            var nb = new byte[] { 1, 2, 3, 3 };
+            nb[3] = a;
+            return nb;
+        }
     }
 }

tests/Neo.Compiler.MSIL.UnitTests/TestClasses/Contract_ContractCall.cs

@@ -0,0 +1,24 @@
+using Neo.SmartContract.Framework;
+
+namespace Neo.Compiler.MSIL.UnitTests.TestClasses
+{
+    [Contract("0102030405060708090A0102030405060708090A")]
+    public class Contract1
+    {
+        public static extern byte[] testArgs(byte a);
+        public static extern void testVoid();
+    }
+
+    public class Contract_ContractCall : SmartContract.Framework.SmartContract
+    {
+        public static byte[] testContractCall()
+        {
+            return Contract1.testArgs((byte)4);
+        }
+
+        public static void testContractCallVoid()
+        {
+            Contract1.testVoid();
+        }
+    }
+}

tests/Neo.Compiler.MSIL.UnitTests/UnitTest_ContractCall.cs

@@ -0,0 +1,49 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Compiler.MSIL.UnitTests.Utils;
+using Neo.IO.Json;
+using Neo.SmartContract.Manifest;
+using Neo.VM;
+using Neo.VM.Types;
+
+namespace Neo.Compiler.MSIL.UnitTests
+{
+    [TestClass]
+    public class UnitTest_ContractCall
+    {
+        private TestEngine _engine;
+
+        [TestInitialize]
+        public void Init()
+        {
+            var hash = UInt160.Parse("0102030405060708090A0102030405060708090A");
+            _engine = new TestEngine();
+            _engine.Snapshot.Contracts.Add(hash, new Ledger.ContractState()
+            {
+                Script = _engine.Build("./TestClasses/Contract1.cs").finalNEF,
+                Manifest = ContractManifest.FromJson(JObject.Parse(_engine.Build("./TestClasses/Contract1.cs").finalManifest)),
+            });
+
+            //will ContractCall 0102030405060708090A0102030405060708090A
+            _engine.AddEntryScript("./TestClasses/Contract_ContractCall.cs");
+        }
+
+        [TestMethod]
+        public void Test_ContractCall()
+        {
+            var result = _engine.GetMethod("testContractCall").Run().ConvertTo(StackItemType.ByteString);
+            Assert.AreEqual(VMState.HALT, _engine.State);
+
+            StackItem wantresult = new byte[] { 1, 2, 3, 4 };
+            var bequal = wantresult.Equals(result);
+            Assert.IsTrue(bequal);
+        }
+
+        [TestMethod]
+        public void Test_ContractCall_Void()
+        {
+            var result = _engine.ExecuteTestCaseStandard("testContractCallVoid");
+            Assert.AreEqual(VMState.HALT, _engine.State);
+            Assert.AreEqual(0, result.Count);
+        }
+    }
+}