From 4df0799c455ca9116d1e863f3bd52c4cb9d5c4fd Mon Sep 17 00:00:00 2001 From: Jinghui Liao Date: Sun, 10 Dec 2023 23:09:15 +0800 Subject: [PATCH 01/11] ensure the value in range --- src/Neo.Compiler.CSharp/MethodConvert.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Neo.Compiler.CSharp/MethodConvert.cs b/src/Neo.Compiler.CSharp/MethodConvert.cs index 5997789ee..fa69aeefb 100644 --- a/src/Neo.Compiler.CSharp/MethodConvert.cs +++ b/src/Neo.Compiler.CSharp/MethodConvert.cs @@ -2918,6 +2918,7 @@ private void ConvertLocalIdentifierNamePostIncrementOrDecrementExpression(Syntax AccessSlot(OpCode.LDLOC, index); AddInstruction(OpCode.DUP); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AccessSlot(OpCode.STLOC, index); } @@ -3146,6 +3147,7 @@ private void ConvertLocalIdentifierNamePreIncrementOrDecrementExpression(SyntaxT byte index = _localVariables[symbol]; AccessSlot(OpCode.LDLOC, index); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STLOC, index); } From 1fed7a707c7bb0d22af0cc975201e6b4cc2f1da4 Mon Sep 17 00:00:00 2001 From: Jinghui Liao Date: Mon, 11 Dec 2023 16:36:48 +0800 Subject: [PATCH 02/11] fix all and add unit test cases --- .../TestClasses/Contract_Inc_Dec.cs | 147 ++++++++++++++++++ .../UnitTest_Inc_Dec.cs | 131 ++++++++++++++++ 2 files changed, 278 insertions(+) create mode 100644 tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs create mode 100644 tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs diff --git a/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs new file mode 100644 index 000000000..8f75573f6 --- /dev/null +++ b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs @@ -0,0 +1,147 @@ +using System; +using System.ComponentModel; + +namespace Neo.Compiler.CSharp.UnitTests.TestClasses +{ + public class Contract2_Inc_Dec : SmartContract.Framework.SmartContract + { + private static uint _property; + + public static uint UnitTest_Property_Inc_Checked() + { + _property = uint.MaxValue; + checked + { + ++_property; + _property++; + } + return _property; + } + + public static uint UnitTest_Property_Inc_UnChecked() + { + _property = uint.MaxValue; + unchecked + { + ++_property; + _property++; + } + return _property; + } + + public static uint UnitTest_Property_Dec_Checked() + { + _property = uint.MinValue; + checked + { + --_property; + _property--; + } + return _property; + } + public static uint UnitTest_Property_Dec_UnChecked() + { + _property = uint.MinValue; + unchecked + { + --_property; + _property--; + } + return _property; + } + + public static uint UnitTest_Local_Dec_Checked() + { + uint local = uint.MinValue; + checked + { + --local; + local--; + } + return local; + } + + public static uint UnitTest_Local_Dec_UnChecked() + { + uint local = uint.MinValue; + unchecked + { + --local; + local--; + } + return local; + } + + public static uint UnitTest_Local_Inc_Checked() + { + uint local = uint.MaxValue; + checked + { + ++local; + local++; + } + return local; + } + + public static uint UnitTest_Local_Inc_UnChecked() + { + uint local = uint.MaxValue; + unchecked + { + ++local; + local++; + } + return local; + } + + public static uint UnitTest_Param_Dec_Checked(uint param) + { + param = uint.MinValue; + checked + { + --param; + param--; + } + return param; + } + + public static uint UnitTest_Param_Dec_UnChecked(uint param) + { + param = uint.MinValue; + unchecked + { + --param; + param--; + } + return param; + } + + public static uint UnitTest_Param_Inc_Checked(uint param) + { + param = uint.MaxValue; + checked + { + ++param; + param++; + } + return param; + } + + public static uint UnitTest_Param_Inc_UnChecked(uint param) + { + param = uint.MaxValue; + unchecked + { + ++param; + param++; + } + return param; + } + + public static void UnitTest_Not_DeadLoop() + { + for (uint i = 5; i < 7; i--) ; + } + + } +} diff --git a/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs new file mode 100644 index 000000000..e8092d18e --- /dev/null +++ b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs @@ -0,0 +1,131 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Neo.Compiler.CSharp.UnitTests.Utils; +using Neo.VM; + +namespace Neo.Compiler.CSharp.UnitTests +{ + [TestClass] + public class UnitTest_Inc_Dec + { + private TestEngine _engine; + + [TestInitialize] + public void Init() + { + _engine = new TestEngine(); + _engine.AddEntryScript("./TestClasses/Contract_Inc_Dec.cs"); + } + + [TestMethod] + public void Test_Property_Inc_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Inc_Checked"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Property_Inc_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Inc_UnChecked"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(1, result.Pop().GetInteger()); + } + + [TestMethod] + public void Test_Property_Dec_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Dec_Checked"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Property_Dec_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Dec_UnChecked"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); + } + + [TestMethod] + public void Test_Local_Inc_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Inc_Checked"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Local_Inc_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Inc_UnChecked"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(1, result.Pop().GetInteger()); + } + + [TestMethod] + public void Test_Local_Dec_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Dec_Checked"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Local_Dec_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Dec_UnChecked"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); + } + + + [TestMethod] + public void Test_Param_Inc_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Inc_Checked", 0); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Param_Inc_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Inc_UnChecked", 0); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(1, result.Pop().GetInteger()); + } + + [TestMethod] + public void Test_Param_Dec_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Dec_Checked", 0); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Param_Dec_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Dec_UnChecked", 0); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); + } + + + [TestMethod] + public void Test_Not_DeadLoop() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Not_DeadLoop"); + Assert.AreEqual(VMState.HALT, _engine.State); + } + } +} From 602c012cf469ed3581c438e109834c328b648fdf Mon Sep 17 00:00:00 2001 From: Jinghui Liao Date: Mon, 11 Dec 2023 16:42:38 +0800 Subject: [PATCH 03/11] missing update --- src/Neo.Compiler.CSharp/MethodConvert.cs | 29 ++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/src/Neo.Compiler.CSharp/MethodConvert.cs b/src/Neo.Compiler.CSharp/MethodConvert.cs index fa69aeefb..a767efbb3 100644 --- a/src/Neo.Compiler.CSharp/MethodConvert.cs +++ b/src/Neo.Compiler.CSharp/MethodConvert.cs @@ -2848,6 +2848,7 @@ private void ConvertElementAccessPostIncrementOrDecrementExpression(SemanticMode AddInstruction(OpCode.REVERSE4); AddInstruction(OpCode.REVERSE3); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(property.Type); Call(model, property.SetMethod!, CallingConvention.StdCall); } else @@ -2861,6 +2862,8 @@ private void ConvertElementAccessPostIncrementOrDecrementExpression(SemanticMode AddInstruction(OpCode.REVERSE4); AddInstruction(OpCode.REVERSE3); EmitIncrementOrDecrement(operatorToken); + var typeSymbol = model.GetTypeInfo(operand).Type; + if (typeSymbol != null) EnsureIntegerInRange(typeSymbol); AddInstruction(OpCode.SETITEM); } } @@ -2895,6 +2898,7 @@ private void ConvertFieldIdentifierNamePostIncrementOrDecrementExpression(Syntax AccessSlot(OpCode.LDSFLD, index); AddInstruction(OpCode.DUP); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AccessSlot(OpCode.STSFLD, index); } else @@ -2906,6 +2910,7 @@ private void ConvertFieldIdentifierNamePostIncrementOrDecrementExpression(Syntax AddInstruction(OpCode.PICKITEM); AddInstruction(OpCode.TUCK); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); Push(index); AddInstruction(OpCode.SWAP); AddInstruction(OpCode.SETITEM); @@ -2928,6 +2933,7 @@ private void ConvertParameterIdentifierNamePostIncrementOrDecrementExpression(Sy AccessSlot(OpCode.LDARG, index); AddInstruction(OpCode.DUP); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AccessSlot(OpCode.STARG, index); } @@ -2938,6 +2944,7 @@ private void ConvertPropertyIdentifierNamePostIncrementOrDecrementExpression(Sem Call(model, symbol.GetMethod!); AddInstruction(OpCode.DUP); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); Call(model, symbol.SetMethod!); } else @@ -2947,6 +2954,7 @@ private void ConvertPropertyIdentifierNamePostIncrementOrDecrementExpression(Sem Call(model, symbol.GetMethod!); AddInstruction(OpCode.TUCK); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } } @@ -2975,6 +2983,7 @@ private void ConvertFieldMemberAccessPostIncrementOrDecrementExpression(Semantic AccessSlot(OpCode.LDSFLD, index); AddInstruction(OpCode.DUP); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AccessSlot(OpCode.STSFLD, index); } else @@ -2986,6 +2995,7 @@ private void ConvertFieldMemberAccessPostIncrementOrDecrementExpression(Semantic AddInstruction(OpCode.PICKITEM); AddInstruction(OpCode.TUCK); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); Push(index); AddInstruction(OpCode.SWAP); AddInstruction(OpCode.SETITEM); @@ -2999,6 +3009,7 @@ private void ConvertPropertyMemberAccessPostIncrementOrDecrementExpression(Seman Call(model, symbol.GetMethod!); AddInstruction(OpCode.DUP); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); Call(model, symbol.SetMethod!); } else @@ -3008,6 +3019,7 @@ private void ConvertPropertyMemberAccessPostIncrementOrDecrementExpression(Seman Call(model, symbol.GetMethod!); AddInstruction(OpCode.TUCK); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } } @@ -3068,6 +3080,11 @@ private void ConvertElementAccessPreIncrementOrDecrementExpression(SemanticModel { if (operand.ArgumentList.Arguments.Count != 1) throw new CompilationException(operand.ArgumentList, DiagnosticId.MultidimensionalArray, $"Unsupported array rank: {operand.ArgumentList.Arguments}"); + + + // ITypeSymbol sType = model.GetTypeInfo(expression.Expression).Type!; + // ITypeSymbol tType = model.GetTypeInfo(expression.Type).Type!; + if (model.GetSymbolInfo(operand).Symbol is IPropertySymbol property) { ConvertExpression(model, operand.Expression); @@ -3076,6 +3093,7 @@ private void ConvertElementAccessPreIncrementOrDecrementExpression(SemanticModel AddInstruction(OpCode.OVER); Call(model, property.GetMethod!, CallingConvention.StdCall); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(property.Type); AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); Call(model, property.SetMethod!, CallingConvention.Cdecl); @@ -3088,6 +3106,8 @@ private void ConvertElementAccessPreIncrementOrDecrementExpression(SemanticModel AddInstruction(OpCode.OVER); AddInstruction(OpCode.PICKITEM); EmitIncrementOrDecrement(operatorToken); + var typeSymbol = model.GetTypeInfo(operand).Type; + if (typeSymbol != null) EnsureIntegerInRange(typeSymbol); AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); AddInstruction(OpCode.REVERSE3); @@ -3124,6 +3144,7 @@ private void ConvertFieldIdentifierNamePreIncrementOrDecrementExpression(SyntaxT byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STSFLD, index); } @@ -3135,6 +3156,7 @@ private void ConvertFieldIdentifierNamePreIncrementOrDecrementExpression(SyntaxT Push(index); AddInstruction(OpCode.PICKITEM); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.TUCK); Push(index); AddInstruction(OpCode.SWAP); @@ -3157,6 +3179,7 @@ private void ConvertParameterIdentifierNamePreIncrementOrDecrementExpression(Syn byte index = _parameters[symbol]; AccessSlot(OpCode.LDARG, index); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STARG, index); } @@ -3167,6 +3190,7 @@ private void ConvertPropertyIdentifierNamePreIncrementOrDecrementExpression(Sema { Call(model, symbol.GetMethod!); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.DUP); Call(model, symbol.SetMethod!); } @@ -3176,6 +3200,7 @@ private void ConvertPropertyIdentifierNamePreIncrementOrDecrementExpression(Sema AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.TUCK); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } @@ -3204,6 +3229,7 @@ private void ConvertFieldMemberAccessPreIncrementOrDecrementExpression(SemanticM byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STSFLD, index); } @@ -3215,6 +3241,7 @@ private void ConvertFieldMemberAccessPreIncrementOrDecrementExpression(SemanticM Push(index); AddInstruction(OpCode.PICKITEM); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.TUCK); Push(index); AddInstruction(OpCode.SWAP); @@ -3228,6 +3255,7 @@ private void ConvertPropertyMemberAccessPreIncrementOrDecrementExpression(Semant { Call(model, symbol.GetMethod!); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.DUP); Call(model, symbol.SetMethod!); } @@ -3237,6 +3265,7 @@ private void ConvertPropertyMemberAccessPreIncrementOrDecrementExpression(Semant AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); EmitIncrementOrDecrement(operatorToken); + EnsureIntegerInRange(symbol.Type); AddInstruction(OpCode.TUCK); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } From c4074667aa2cf3fcd90e21b0c41b67870449becf Mon Sep 17 00:00:00 2001 From: Jimmy Date: Mon, 11 Dec 2023 16:49:04 +0800 Subject: [PATCH 04/11] Update src/Neo.Compiler.CSharp/MethodConvert.cs --- src/Neo.Compiler.CSharp/MethodConvert.cs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/Neo.Compiler.CSharp/MethodConvert.cs b/src/Neo.Compiler.CSharp/MethodConvert.cs index a767efbb3..6d63bba9f 100644 --- a/src/Neo.Compiler.CSharp/MethodConvert.cs +++ b/src/Neo.Compiler.CSharp/MethodConvert.cs @@ -3080,11 +3080,6 @@ private void ConvertElementAccessPreIncrementOrDecrementExpression(SemanticModel { if (operand.ArgumentList.Arguments.Count != 1) throw new CompilationException(operand.ArgumentList, DiagnosticId.MultidimensionalArray, $"Unsupported array rank: {operand.ArgumentList.Arguments}"); - - - // ITypeSymbol sType = model.GetTypeInfo(expression.Expression).Type!; - // ITypeSymbol tType = model.GetTypeInfo(expression.Type).Type!; - if (model.GetSymbolInfo(operand).Symbol is IPropertySymbol property) { ConvertExpression(model, operand.Expression); From a80eda5a0cab4ad1db73f6d5d9eee268133e790d Mon Sep 17 00:00:00 2001 From: Shargon Date: Mon, 11 Dec 2023 10:37:44 +0100 Subject: [PATCH 05/11] Update tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs --- tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs index e8092d18e..eaea5a6b4 100644 --- a/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs +++ b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs @@ -83,8 +83,6 @@ public void Test_Local_Dec_UnChecked() Assert.AreEqual(VMState.HALT, _engine.State); Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); } - - [TestMethod] public void Test_Param_Inc_Checked() { From 2e8406b6d421d9663e45d867f4e041d4a844391f Mon Sep 17 00:00:00 2001 From: Shargon Date: Mon, 11 Dec 2023 10:37:52 +0100 Subject: [PATCH 06/11] Update tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs --- tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs index eaea5a6b4..7b91d070d 100644 --- a/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs +++ b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs @@ -116,8 +116,6 @@ public void Test_Param_Dec_UnChecked() Assert.AreEqual(VMState.HALT, _engine.State); Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); } - - [TestMethod] public void Test_Not_DeadLoop() { From fb1583b2fba8e4248b6e89ac1e917a433f30784c Mon Sep 17 00:00:00 2001 From: Shargon Date: Mon, 11 Dec 2023 10:38:04 +0100 Subject: [PATCH 07/11] Update tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs --- .../TestClasses/Contract_Inc_Dec.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs index 8f75573f6..e856273a8 100644 --- a/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs +++ b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs @@ -39,6 +39,7 @@ public static uint UnitTest_Property_Dec_Checked() } return _property; } + public static uint UnitTest_Property_Dec_UnChecked() { _property = uint.MinValue; From ad25b001dc664731ac9f0e8c6ad6b63b631b0ea4 Mon Sep 17 00:00:00 2001 From: Jinghui Liao Date: Tue, 12 Dec 2023 16:48:59 +0800 Subject: [PATCH 08/11] optimize the check --- src/Neo.Compiler.CSharp/MethodConvert.cs | 77 ++++++++---------------- 1 file changed, 26 insertions(+), 51 deletions(-) diff --git a/src/Neo.Compiler.CSharp/MethodConvert.cs b/src/Neo.Compiler.CSharp/MethodConvert.cs index a767efbb3..be21ffb14 100644 --- a/src/Neo.Compiler.CSharp/MethodConvert.cs +++ b/src/Neo.Compiler.CSharp/MethodConvert.cs @@ -2847,8 +2847,7 @@ private void ConvertElementAccessPostIncrementOrDecrementExpression(SemanticMode AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); AddInstruction(OpCode.REVERSE3); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(property.Type); + EmitIncrementOrDecrement(operatorToken,property.Type); Call(model, property.SetMethod!, CallingConvention.StdCall); } else @@ -2861,9 +2860,7 @@ private void ConvertElementAccessPostIncrementOrDecrementExpression(SemanticMode AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); AddInstruction(OpCode.REVERSE3); - EmitIncrementOrDecrement(operatorToken); - var typeSymbol = model.GetTypeInfo(operand).Type; - if (typeSymbol != null) EnsureIntegerInRange(typeSymbol); + EmitIncrementOrDecrement(operatorToken, model.GetTypeInfo(operand).Type); AddInstruction(OpCode.SETITEM); } } @@ -2897,8 +2894,7 @@ private void ConvertFieldIdentifierNamePostIncrementOrDecrementExpression(Syntax byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AccessSlot(OpCode.STSFLD, index); } else @@ -2909,8 +2905,7 @@ private void ConvertFieldIdentifierNamePostIncrementOrDecrementExpression(Syntax Push(index); AddInstruction(OpCode.PICKITEM); AddInstruction(OpCode.TUCK); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); Push(index); AddInstruction(OpCode.SWAP); AddInstruction(OpCode.SETITEM); @@ -2922,8 +2917,7 @@ private void ConvertLocalIdentifierNamePostIncrementOrDecrementExpression(Syntax byte index = _localVariables[symbol]; AccessSlot(OpCode.LDLOC, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AccessSlot(OpCode.STLOC, index); } @@ -2932,8 +2926,7 @@ private void ConvertParameterIdentifierNamePostIncrementOrDecrementExpression(Sy byte index = _parameters[symbol]; AccessSlot(OpCode.LDARG, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AccessSlot(OpCode.STARG, index); } @@ -2943,8 +2936,7 @@ private void ConvertPropertyIdentifierNamePostIncrementOrDecrementExpression(Sem { Call(model, symbol.GetMethod!); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); Call(model, symbol.SetMethod!); } else @@ -2953,8 +2945,7 @@ private void ConvertPropertyIdentifierNamePostIncrementOrDecrementExpression(Sem AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); AddInstruction(OpCode.TUCK); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } } @@ -2982,8 +2973,7 @@ private void ConvertFieldMemberAccessPostIncrementOrDecrementExpression(Semantic byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AccessSlot(OpCode.STSFLD, index); } else @@ -2994,8 +2984,7 @@ private void ConvertFieldMemberAccessPostIncrementOrDecrementExpression(Semantic Push(index); AddInstruction(OpCode.PICKITEM); AddInstruction(OpCode.TUCK); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); Push(index); AddInstruction(OpCode.SWAP); AddInstruction(OpCode.SETITEM); @@ -3008,8 +2997,7 @@ private void ConvertPropertyMemberAccessPostIncrementOrDecrementExpression(Seman { Call(model, symbol.GetMethod!); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); Call(model, symbol.SetMethod!); } else @@ -3018,8 +3006,7 @@ private void ConvertPropertyMemberAccessPostIncrementOrDecrementExpression(Seman AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); AddInstruction(OpCode.TUCK); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } } @@ -3092,8 +3079,7 @@ private void ConvertElementAccessPreIncrementOrDecrementExpression(SemanticModel AddInstruction(OpCode.OVER); AddInstruction(OpCode.OVER); Call(model, property.GetMethod!, CallingConvention.StdCall); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(property.Type); + EmitIncrementOrDecrement(operatorToken,property.Type); AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); Call(model, property.SetMethod!, CallingConvention.Cdecl); @@ -3105,9 +3091,7 @@ private void ConvertElementAccessPreIncrementOrDecrementExpression(SemanticModel AddInstruction(OpCode.OVER); AddInstruction(OpCode.OVER); AddInstruction(OpCode.PICKITEM); - EmitIncrementOrDecrement(operatorToken); - var typeSymbol = model.GetTypeInfo(operand).Type; - if (typeSymbol != null) EnsureIntegerInRange(typeSymbol); + EmitIncrementOrDecrement(operatorToken, model.GetTypeInfo(operand).Type); AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); AddInstruction(OpCode.REVERSE3); @@ -3143,8 +3127,7 @@ private void ConvertFieldIdentifierNamePreIncrementOrDecrementExpression(SyntaxT { byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STSFLD, index); } @@ -3155,8 +3138,7 @@ private void ConvertFieldIdentifierNamePreIncrementOrDecrementExpression(SyntaxT AddInstruction(OpCode.DUP); Push(index); AddInstruction(OpCode.PICKITEM); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.TUCK); Push(index); AddInstruction(OpCode.SWAP); @@ -3168,8 +3150,7 @@ private void ConvertLocalIdentifierNamePreIncrementOrDecrementExpression(SyntaxT { byte index = _localVariables[symbol]; AccessSlot(OpCode.LDLOC, index); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STLOC, index); } @@ -3178,8 +3159,7 @@ private void ConvertParameterIdentifierNamePreIncrementOrDecrementExpression(Syn { byte index = _parameters[symbol]; AccessSlot(OpCode.LDARG, index); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STARG, index); } @@ -3189,8 +3169,7 @@ private void ConvertPropertyIdentifierNamePreIncrementOrDecrementExpression(Sema if (symbol.IsStatic) { Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.DUP); Call(model, symbol.SetMethod!); } @@ -3199,8 +3178,7 @@ private void ConvertPropertyIdentifierNamePreIncrementOrDecrementExpression(Sema AddInstruction(OpCode.LDARG0); AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.TUCK); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } @@ -3228,8 +3206,7 @@ private void ConvertFieldMemberAccessPreIncrementOrDecrementExpression(SemanticM { byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STSFLD, index); } @@ -3240,8 +3217,7 @@ private void ConvertFieldMemberAccessPreIncrementOrDecrementExpression(SemanticM AddInstruction(OpCode.DUP); Push(index); AddInstruction(OpCode.PICKITEM); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.TUCK); Push(index); AddInstruction(OpCode.SWAP); @@ -3254,8 +3230,7 @@ private void ConvertPropertyMemberAccessPreIncrementOrDecrementExpression(Semant if (symbol.IsStatic) { Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.DUP); Call(model, symbol.SetMethod!); } @@ -3264,14 +3239,13 @@ private void ConvertPropertyMemberAccessPreIncrementOrDecrementExpression(Semant ConvertExpression(model, operand.Expression); AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken); - EnsureIntegerInRange(symbol.Type); + EmitIncrementOrDecrement(operatorToken,symbol.Type); AddInstruction(OpCode.TUCK); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } } - private void EmitIncrementOrDecrement(SyntaxToken operatorToken) + private void EmitIncrementOrDecrement(SyntaxToken operatorToken, ITypeSymbol? typeSymbol) { AddInstruction(operatorToken.ValueText switch { @@ -3279,6 +3253,7 @@ private void EmitIncrementOrDecrement(SyntaxToken operatorToken) "--" => OpCode.DEC, _ => throw new CompilationException(operatorToken, DiagnosticId.SyntaxNotSupported, $"Unsupported operator: {operatorToken}") }); + if (typeSymbol != null) EnsureIntegerInRange(typeSymbol); } private void ConvertSwitchExpression(SemanticModel model, SwitchExpressionSyntax expression) From f52fb2211a4d412fc31df0c8d735926ab7e49702 Mon Sep 17 00:00:00 2001 From: Jinghui Liao Date: Tue, 12 Dec 2023 19:37:05 +0800 Subject: [PATCH 09/11] fix format --- src/Neo.Compiler.CSharp/MethodConvert.cs | 40 ++++++++++++------------ 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/Neo.Compiler.CSharp/MethodConvert.cs b/src/Neo.Compiler.CSharp/MethodConvert.cs index 5541724ce..fb24e5d97 100644 --- a/src/Neo.Compiler.CSharp/MethodConvert.cs +++ b/src/Neo.Compiler.CSharp/MethodConvert.cs @@ -2847,7 +2847,7 @@ private void ConvertElementAccessPostIncrementOrDecrementExpression(SemanticMode AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); AddInstruction(OpCode.REVERSE3); - EmitIncrementOrDecrement(operatorToken,property.Type); + EmitIncrementOrDecrement(operatorToken, property.Type); Call(model, property.SetMethod!, CallingConvention.StdCall); } else @@ -2894,7 +2894,7 @@ private void ConvertFieldIdentifierNamePostIncrementOrDecrementExpression(Syntax byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AccessSlot(OpCode.STSFLD, index); } else @@ -2905,7 +2905,7 @@ private void ConvertFieldIdentifierNamePostIncrementOrDecrementExpression(Syntax Push(index); AddInstruction(OpCode.PICKITEM); AddInstruction(OpCode.TUCK); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); Push(index); AddInstruction(OpCode.SWAP); AddInstruction(OpCode.SETITEM); @@ -2917,7 +2917,7 @@ private void ConvertLocalIdentifierNamePostIncrementOrDecrementExpression(Syntax byte index = _localVariables[symbol]; AccessSlot(OpCode.LDLOC, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AccessSlot(OpCode.STLOC, index); } @@ -2926,7 +2926,7 @@ private void ConvertParameterIdentifierNamePostIncrementOrDecrementExpression(Sy byte index = _parameters[symbol]; AccessSlot(OpCode.LDARG, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AccessSlot(OpCode.STARG, index); } @@ -2936,7 +2936,7 @@ private void ConvertPropertyIdentifierNamePostIncrementOrDecrementExpression(Sem { Call(model, symbol.GetMethod!); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); Call(model, symbol.SetMethod!); } else @@ -2945,7 +2945,7 @@ private void ConvertPropertyIdentifierNamePostIncrementOrDecrementExpression(Sem AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); AddInstruction(OpCode.TUCK); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } } @@ -2973,7 +2973,7 @@ private void ConvertFieldMemberAccessPostIncrementOrDecrementExpression(Semantic byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); AddInstruction(OpCode.DUP); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AccessSlot(OpCode.STSFLD, index); } else @@ -3006,7 +3006,7 @@ private void ConvertPropertyMemberAccessPostIncrementOrDecrementExpression(Seman AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); AddInstruction(OpCode.TUCK); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } } @@ -3074,7 +3074,7 @@ private void ConvertElementAccessPreIncrementOrDecrementExpression(SemanticModel AddInstruction(OpCode.OVER); AddInstruction(OpCode.OVER); Call(model, property.GetMethod!, CallingConvention.StdCall); - EmitIncrementOrDecrement(operatorToken,property.Type); + EmitIncrementOrDecrement(operatorToken, property.Type); AddInstruction(OpCode.DUP); AddInstruction(OpCode.REVERSE4); Call(model, property.SetMethod!, CallingConvention.Cdecl); @@ -3122,7 +3122,7 @@ private void ConvertFieldIdentifierNamePreIncrementOrDecrementExpression(SyntaxT { byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STSFLD, index); } @@ -3133,7 +3133,7 @@ private void ConvertFieldIdentifierNamePreIncrementOrDecrementExpression(SyntaxT AddInstruction(OpCode.DUP); Push(index); AddInstruction(OpCode.PICKITEM); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.TUCK); Push(index); AddInstruction(OpCode.SWAP); @@ -3145,7 +3145,7 @@ private void ConvertLocalIdentifierNamePreIncrementOrDecrementExpression(SyntaxT { byte index = _localVariables[symbol]; AccessSlot(OpCode.LDLOC, index); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STLOC, index); } @@ -3154,7 +3154,7 @@ private void ConvertParameterIdentifierNamePreIncrementOrDecrementExpression(Syn { byte index = _parameters[symbol]; AccessSlot(OpCode.LDARG, index); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STARG, index); } @@ -3164,7 +3164,7 @@ private void ConvertPropertyIdentifierNamePreIncrementOrDecrementExpression(Sema if (symbol.IsStatic) { Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.DUP); Call(model, symbol.SetMethod!); } @@ -3173,7 +3173,7 @@ private void ConvertPropertyIdentifierNamePreIncrementOrDecrementExpression(Sema AddInstruction(OpCode.LDARG0); AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.TUCK); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } @@ -3201,7 +3201,7 @@ private void ConvertFieldMemberAccessPreIncrementOrDecrementExpression(SemanticM { byte index = context.AddStaticField(symbol); AccessSlot(OpCode.LDSFLD, index); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.DUP); AccessSlot(OpCode.STSFLD, index); } @@ -3212,7 +3212,7 @@ private void ConvertFieldMemberAccessPreIncrementOrDecrementExpression(SemanticM AddInstruction(OpCode.DUP); Push(index); AddInstruction(OpCode.PICKITEM); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.TUCK); Push(index); AddInstruction(OpCode.SWAP); @@ -3225,7 +3225,7 @@ private void ConvertPropertyMemberAccessPreIncrementOrDecrementExpression(Semant if (symbol.IsStatic) { Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.DUP); Call(model, symbol.SetMethod!); } @@ -3234,7 +3234,7 @@ private void ConvertPropertyMemberAccessPreIncrementOrDecrementExpression(Semant ConvertExpression(model, operand.Expression); AddInstruction(OpCode.DUP); Call(model, symbol.GetMethod!); - EmitIncrementOrDecrement(operatorToken,symbol.Type); + EmitIncrementOrDecrement(operatorToken, symbol.Type); AddInstruction(OpCode.TUCK); Call(model, symbol.SetMethod!, CallingConvention.StdCall); } From 313118db3994e42414e31df5d67b5098ab6b7fb4 Mon Sep 17 00:00:00 2001 From: Jinghui Liao Date: Tue, 12 Dec 2023 20:37:06 +0800 Subject: [PATCH 10/11] also add test for int --- .../TestClasses/Contract_Inc_Dec.cs | 135 ++++++++++++++++++ .../UnitTest_Inc_Dec.cs | 118 ++++++++++++++- 2 files changed, 247 insertions(+), 6 deletions(-) diff --git a/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs index e856273a8..d20f9122a 100644 --- a/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs +++ b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs @@ -6,6 +6,7 @@ namespace Neo.Compiler.CSharp.UnitTests.TestClasses public class Contract2_Inc_Dec : SmartContract.Framework.SmartContract { private static uint _property; + private static int _intProperty; public static uint UnitTest_Property_Inc_Checked() { @@ -139,6 +140,140 @@ public static uint UnitTest_Param_Inc_UnChecked(uint param) return param; } + public static int UnitTest_Property_Inc_Checked_Int() + { + _intProperty = int.MaxValue; + checked + { + ++_intProperty; + _intProperty++; + } + return _intProperty; + } + + public static int UnitTest_Property_Inc_UnChecked_Int() + { + _intProperty = int.MaxValue; + unchecked + { + ++_intProperty; + _intProperty++; + } + return _intProperty; + } + + public static int UnitTest_Property_Dec_Checked_Int() + { + _intProperty = int.MinValue; + checked + { + --_intProperty; + _intProperty--; + } + return _intProperty; + } + + public static int UnitTest_Property_Dec_UnChecked_Int() + { + _intProperty = int.MinValue; + unchecked + { + --_intProperty; + _intProperty--; + } + return _intProperty; + } + + // Local Variable Tests + public static int UnitTest_Local_Inc_Checked_Int() + { + int local = int.MaxValue; + checked + { + ++local; + local++; + } + return local; + } + + public static int UnitTest_Local_Inc_UnChecked_Int() + { + int local = int.MaxValue; + unchecked + { + ++local; + local++; + } + return local; + } + + public static int UnitTest_Local_Dec_Checked_Int() + { + int local = int.MinValue; + checked + { + --local; + local--; + } + return local; + } + + public static int UnitTest_Local_Dec_UnChecked_Int() + { + int local = int.MinValue; + unchecked + { + --local; + local--; + } + return local; + } + + // Parameter Tests + public static int UnitTest_Param_Inc_Checked_Int(int param) + { + param = int.MaxValue; + checked + { + ++param; + param++; + } + return param; + } + + public static int UnitTest_Param_Inc_UnChecked_Int(int param) + { + param = int.MaxValue; + unchecked + { + ++param; + param++; + } + return param; + } + + public static int UnitTest_Param_Dec_Checked_Int(int param) + { + param = int.MinValue; + checked + { + --param; + param--; + } + return param; + } + + public static int UnitTest_Param_Dec_UnChecked_Int(int param) + { + param = int.MinValue; + unchecked + { + --param; + param--; + } + return param; + } + public static void UnitTest_Not_DeadLoop() { for (uint i = 5; i < 7; i--) ; diff --git a/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs index 7b91d070d..7003cafdd 100644 --- a/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs +++ b/tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Inc_Dec.cs @@ -30,7 +30,7 @@ public void Test_Property_Inc_UnChecked() _engine.Reset(); var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Inc_UnChecked"); Assert.AreEqual(VMState.HALT, _engine.State); - Assert.AreEqual(1, result.Pop().GetInteger()); + Assert.AreEqual(unchecked(uint.MaxValue + 2), result.Pop().GetInteger()); } [TestMethod] @@ -47,7 +47,7 @@ public void Test_Property_Dec_UnChecked() _engine.Reset(); var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Dec_UnChecked"); Assert.AreEqual(VMState.HALT, _engine.State); - Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); + Assert.AreEqual(unchecked(uint.MinValue - 2), result.Pop().GetInteger()); } [TestMethod] @@ -64,7 +64,7 @@ public void Test_Local_Inc_UnChecked() _engine.Reset(); var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Inc_UnChecked"); Assert.AreEqual(VMState.HALT, _engine.State); - Assert.AreEqual(1, result.Pop().GetInteger()); + Assert.AreEqual(unchecked(uint.MaxValue + 2), result.Pop().GetInteger()); } [TestMethod] @@ -81,7 +81,7 @@ public void Test_Local_Dec_UnChecked() _engine.Reset(); var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Dec_UnChecked"); Assert.AreEqual(VMState.HALT, _engine.State); - Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); + Assert.AreEqual(unchecked(uint.MinValue - 2), result.Pop().GetInteger()); } [TestMethod] public void Test_Param_Inc_Checked() @@ -97,7 +97,7 @@ public void Test_Param_Inc_UnChecked() _engine.Reset(); var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Inc_UnChecked", 0); Assert.AreEqual(VMState.HALT, _engine.State); - Assert.AreEqual(1, result.Pop().GetInteger()); + Assert.AreEqual(unchecked(uint.MaxValue + 2), result.Pop().GetInteger()); } [TestMethod] @@ -114,8 +114,114 @@ public void Test_Param_Dec_UnChecked() _engine.Reset(); var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Dec_UnChecked", 0); Assert.AreEqual(VMState.HALT, _engine.State); - Assert.AreEqual(uint.MaxValue - 1, result.Pop().GetInteger()); + Assert.AreEqual(unchecked(uint.MinValue - 2), result.Pop().GetInteger()); } + + // Test Methods for int type + [TestMethod] + public void Test_IntProperty_Inc_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Inc_Checked_Int"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_IntProperty_Inc_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Inc_UnChecked_Int"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(unchecked(int.MaxValue + 2), result.Pop().GetInteger()); + } + + [TestMethod] + public void Test_IntProperty_Dec_Checked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Dec_Checked_Int"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_IntProperty_Dec_UnChecked() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Property_Dec_UnChecked_Int"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(unchecked(int.MinValue - 2), result.Pop().GetInteger()); + } + + // Local Variable Tests for int + [TestMethod] + public void Test_Local_Inc_Checked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Inc_Checked_Int"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Local_Inc_UnChecked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Inc_UnChecked_Int"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(unchecked(int.MaxValue + 2), result.Pop().GetInteger()); + } + + [TestMethod] + public void Test_Local_Dec_Checked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Dec_Checked_Int"); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Local_Dec_UnChecked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Local_Dec_UnChecked_Int"); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(unchecked(int.MinValue - 2), result.Pop().GetInteger()); + } + + // Parameter Tests for int + [TestMethod] + public void Test_Param_Inc_Checked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Inc_Checked_Int", 0); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Param_Inc_UnChecked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Inc_UnChecked_Int", 0); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(unchecked(int.MaxValue + 2), result.Pop().GetInteger()); + } + + [TestMethod] + public void Test_Param_Dec_Checked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Dec_Checked_Int", 0); + Assert.AreEqual(VMState.FAULT, _engine.State); + } + + [TestMethod] + public void Test_Param_Dec_UnChecked_Int() + { + _engine.Reset(); + var result = _engine.ExecuteTestCaseStandard("unitTest_Param_Dec_UnChecked_Int", 0); + Assert.AreEqual(VMState.HALT, _engine.State); + Assert.AreEqual(unchecked(int.MinValue - 2), result.Pop().GetInteger()); + } + [TestMethod] public void Test_Not_DeadLoop() { From 5278e118f6d2fc5cc24031af2696fc222a71d48b Mon Sep 17 00:00:00 2001 From: Shargon Date: Fri, 15 Dec 2023 02:02:08 -0800 Subject: [PATCH 11/11] Update tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs --- .../TestClasses/Contract_Inc_Dec.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs index d20f9122a..77f39387d 100644 --- a/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs +++ b/tests/Neo.Compiler.CSharp.UnitTests/TestClasses/Contract_Inc_Dec.cs @@ -278,6 +278,5 @@ public static void UnitTest_Not_DeadLoop() { for (uint i = 5; i < 7; i--) ; } - } }