[Compiler Add ]Recursive pattern

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

@@ -78,6 +78,9 @@ private void ConvertPattern(SemanticModel model, PatternSyntax pattern, byte loc
             case ParenthesizedPatternSyntax parenthesizedPattern:
                 ConvertParenthesizedPatternSyntax(model, parenthesizedPattern, localIndex);
                 break;
+            case RecursivePatternSyntax recursivePattern:
+                ConvertRecursivePattern(model, recursivePattern, localIndex);
+                break;
             default:
                 //Example:
                 //object greeting = "Hello, World!";

src/Neo.Compiler.CSharp/MethodConvert/Pattern/RecursivePattern.cs

@@ -0,0 +1,59 @@
+// Copyright (C) 2015-2023 The Neo Project.
+//
+// The Neo.Compiler.CSharp is free software distributed under the MIT
+// software license, see the accompanying file LICENSE in the main directory
+// of the project or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+extern alias scfx;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Neo.VM;
+
+namespace Neo.Compiler;
+
+partial class MethodConvert
+{
+    private void ConvertRecursivePattern(SemanticModel model, RecursivePatternSyntax pattern, byte localIndex)
+    {
+        if (pattern.PropertyPatternClause is { } propertyClause)
+        {
+            AccessSlot(OpCode.LDLOC, localIndex);
+            foreach (var subpattern in propertyClause.Subpatterns)
+            {
+                if (subpattern is { Pattern: ConstantPatternSyntax constantPattern })
+                {
+                    // Example:
+                    // if (newOwner is { IsValid: true, IsZero:false})
+                    // {
+                    // }
+                    var propertySymbol = model.GetSymbolInfo(subpattern.NameColon!.Name).Symbol!;
+
+                    if (propertySymbol is IPropertySymbol property)
+                    {
+                        Call(model, property.GetMethod!);
+                    }
+                    else
+                    {
+                        throw new CompilationException(subpattern, DiagnosticId.SyntaxNotSupported, $"Unsupported property or field: {subpattern.NameColon.Name}");
+                    }
+                    object? constantValue = model.GetConstantValue(constantPattern.Expression).Value;
+                    Push(constantValue);
+                    AddInstruction(OpCode.EQUAL);
+                }
+                else
+                {
+                    throw new CompilationException(subpattern, DiagnosticId.SyntaxNotSupported, $"Unsupported subpattern: {subpattern}");
+                }
+            }
+        }
+        else
+        {
+            throw new CompilationException(pattern, DiagnosticId.SyntaxNotSupported, $"Unsupported pattern: {pattern}");
+        }
+    }
+}

tests/Neo.Compiler.CSharp.TestContracts/Contract1.cs

@@ -1,3 +1,5 @@
+using Neo.SmartContract.Framework;
+
 namespace Neo.Compiler.CSharp.UnitTests.TestClasses
 {
     public class Contract1 : SmartContract.Framework.SmartContract
@@ -40,5 +42,6 @@ public static int testArgs4(int a, int b)
             a = a + 2;
             return a + b;
         }
+
     }
 }

tests/Neo.Compiler.CSharp.TestContracts/Contract_Pattern.cs

@@ -26,6 +26,17 @@ public bool between3(int value)
             };
         }
 
+        public bool testRecursivePattern()
+        {
+            UInt160? newOwner = UInt160.Zero;
+
+            return newOwner switch
+            {
+                { IsValid: true, IsZero: false } => true,
+                _ => false,
+            };
+        }
+
         public bool between4(int value)
         {
             return value is <= 0;

tests/Neo.Compiler.CSharp.UnitTests/UnitTest_Pattern.cs

@@ -86,5 +86,16 @@ public void Between3_Test()
             value = result.Pop().GetBoolean();
             Assert.AreEqual(false, value);
         }
+
+        [TestMethod]
+        public void RecursivePattern_Test()
+        {
+            using var testengine = new TestEngine();
+            testengine.AddEntryScript(Utils.Extensions.TestContractRoot + "Contract_Pattern.cs");
+
+            var result = testengine.ExecuteTestCaseStandard("testRecursivePattern");
+            var value = result.Pop().GetBoolean();
+            Assert.AreEqual(true, value);
+        }
     }
 }