Feature/matching dsl related to #20

docs/api-walkthrough.md

@@ -97,6 +97,31 @@ if (inst is BinaryInst { Op: BinaryOp.Sub, Left: BinaryInst { Op: BinaryOp.Add }
 }
 ```
 
+or you can use the pattern matching dsl:
+```csharp
+if (ins.Match("(sub {lhs: (add {x} $y)} $y)", out var outputs))
+{
+    inst.ReplaceWith(outputs["lhs"]);
+}
+```
+
+Pattern Matching Operations:
+| Example    | Description                                                            |
+|------------|------------------------------------------------------------------------|
+| $x         | Use the value later for matching                                       |
+| {x}        | Output the operand                                                     |
+| {x: (add)} | Output the operand if the subpattern matched                           |
+| _          | Ignore the operand                                                     |
+| !          | Matches if the subpattern doesn't match                                |
+| #instr     | Matches if the operand is an instruction                               |
+| #const     | Matches if the operand is a constant                                   |
+| #int       | Matches if the operand is a constant of type int32                     |
+| >5         | Matches if the value is greater than 5                                 |
+| <5         | Matches if the value is less than 5                                    |
+| *"hello"*  | Matches if the operand is a string constant that contains the value    |
+| *"hello"   | Matches if the operand is a string constant that end with the value    |
+| "hello"*   | Matches if the operand is a string constant that starts with the value |
+=======
 ## Finding Methods
 
 The module resolver has an `FindMethod` extension method that makes it easier to find methods from the IR.

src/DistIL/AsmIO/ResolvingUtils.cs

@@ -70,7 +70,7 @@ public static class ResolvingUtils
         return methods.FirstOrDefault();
     }
 
-    private static MethodSelector GetSelector(this ModuleResolver resolver, string selector)
+    internal static MethodSelector GetSelector(this ModuleResolver resolver, string selector)
     {
         var spl = selector.Split("::");
         var type = FindType(resolver, spl[0].Trim());

src/DistIL/IR/DSL/IInstructionPatternArgument.cs

@@ -0,0 +1,6 @@
+namespace DistIL.IR.DSL;
+
+internal interface IInstructionPatternArgument
+{
+
+}

src/DistIL/IR/DSL/InstructionPattern.cs

@@ -0,0 +1,227 @@
+namespace DistIL.IR.DSL;
+
+using System;
+using System.Collections.Generic;
+
+using PatternArguments;
+using Utils.Parser;
+
+internal record InstructionPattern(
+    Opcode OpCode,
+    string Operation,
+    List<IInstructionPatternArgument> Arguments)
+    : IInstructionPatternArgument
+{
+    public static IInstructionPatternArgument? Parse(ReadOnlySpan<char> pattern)
+    {
+        // Remove whitespace and validate parentheses balance
+        pattern = pattern.Trim();
+        if (pattern.Length == 0) {
+            return null;
+        }
+
+        if (pattern[0] != '(' || pattern[^1] != ')')
+            return ParseArgument(pattern);
+
+        // Remove the outer parentheses
+        pattern = pattern[1..^1].Trim();
+
+        // Split the operation from its arguments
+        int spaceIndex = pattern.IndexOf(' ');
+        if (spaceIndex == -1) {
+            spaceIndex = pattern.Length;
+        }
+
+        var op = pattern[..spaceIndex].ToString();
+        var operation = Opcodes.TryParse(op); // TryParse does not support span yet
+        var argsString = pattern[spaceIndex..].Trim();
+
+        List<IInstructionPatternArgument> arguments = new List<IInstructionPatternArgument>();
+
+        if (operation.Op is Opcode.Call or Opcode.CallVirt) {
+            var selector = argsString[..argsString.IndexOf(' ')].ToString();
+            arguments.Add(new MethodRefArgument(selector));
+
+            argsString = argsString[argsString.IndexOf(' ')..];
+        }
+
+        ParseArguments(argsString, arguments);
+
+        return new InstructionPattern(operation.Op, op, arguments);
+    }
+
+    private static IInstructionPatternArgument? ParseEval(ReadOnlySpan<char> pattern)
+    {
+        var op = pattern[1..].Trim();
+
+        return new EvalArgument(ParseArgument(op));
+    }
+
+    private static void ParseArguments(ReadOnlySpan<char> argsString, List<IInstructionPatternArgument> arguments)
+    {
+        int depth = 0;
+        string currentArg = "";
+        Stack<char> outputStack = new();
+
+        foreach (var c in argsString)
+        {
+            if (c == '{') {
+                outputStack.Push(c);
+            }
+            else if (c == '}') {
+                outputStack.Pop();
+            }
+
+            if (c == '(')
+            {
+                depth++;
+                currentArg += c;
+            }
+            else if (c == ')')
+            {
+                depth--;
+                currentArg += c;
+                if (depth == 0 && outputStack.Count == 0)
+                {
+                    // Completed a nested argument
+                    arguments.Add(Parse(currentArg.AsSpan())!);
+                    currentArg = "";
+                }
+            }
+            else if (char.IsWhiteSpace(c) && depth == 0)
+            {
+                // End of a top-level argument
+                if (!string.IsNullOrWhiteSpace(currentArg))
+                {
+                    arguments.Add(ParseArgument(currentArg.Trim()));
+                    currentArg = "";
+                }
+            }
+            else
+            {
+                currentArg += c;
+            }
+        }
+
+        // Add any remaining argument
+        if (!string.IsNullOrWhiteSpace(currentArg))
+        {
+            arguments.Add(ParseArgument(currentArg.Trim()));
+        }
+    }
+
+    private static IInstructionPatternArgument ParseArgument(ReadOnlySpan<char> arg)
+    {
+        if (arg[0] == '(' && arg[^1] == ')') {
+            return Parse(arg)!;
+        }
+
+        if (arg.Contains('#'))
+        {
+            var left = arg[..arg.IndexOf('#')];
+            var typeSpecifier = arg[arg.IndexOf('#')..].TrimStart('#');
+
+            var argument = left is not "" ? ParseArgument(left) : null;
+            return new TypedArgument(argument, typeSpecifier.ToString());
+        }
+
+        if (arg[0] == '!') {
+            return ParseNot(arg);
+        }
+
+        if (arg[0] == '$') {
+            return ParseBuffer(arg);
+        }
+
+        if (arg[0] == '<' || arg[0] == '>') {
+            return ParseNumOperator(arg);
+        }
+
+        if (arg[0] == '#') {
+            return new TypedArgument(default, arg[1..].ToString());
+        }
+
+        if (arg[0] == '*' || arg[0] == '\'')
+        {
+            return ParseStringArgument(arg);
+        }
+
+        if (arg[0] == '{' && arg[^1] == '}') {
+            return ParseOutputArgument(arg);
+        }
+
+        if (arg[0] == '_')
+        {
+            return new IgnoreArgument();
+        }
+
+        if (long.TryParse(arg, out var number))
+        {
+            return new ConstantArgument(number, PrimType.Int64);
+        }
+        if (double.TryParse(arg, out var dnumber))
+        {
+            return new ConstantArgument(dnumber, PrimType.Double);
+        }
+
+        throw new ArgumentException("Invalid Argument");
+    }
+
+    private static IInstructionPatternArgument ParseOutputArgument(ReadOnlySpan<char> arg)
+    {
+        arg = arg[1..^1];
+
+        if (arg.Contains(':')) {
+            var name = arg[..arg.IndexOf(':')];
+            var subPattern = ParseArgument(arg[(arg.IndexOf(':') + 1)..]);
+
+            return new OutputArgument(name.ToString(), subPattern);
+        }
+
+        return new OutputArgument(arg.ToString());
+    }
+
+    private static IInstructionPatternArgument ParseBuffer(ReadOnlySpan<char> arg)
+    {
+        return new BufferArgument(arg[1..].ToString());
+    }
+
+    private static IInstructionPatternArgument ParseNumOperator(ReadOnlySpan<char> arg)
+    {
+        var op = arg[0];
+
+        return new NumberOperatorArgument(op, ParseArgument(arg[1..]));
+    }
+
+
+    private static IInstructionPatternArgument ParseNot(ReadOnlySpan<char> arg)
+    {
+        var trimmed = arg.TrimStart('!');
+
+        return new NotArgument(ParseArgument(trimmed));
+    }
+
+    private static IInstructionPatternArgument ParseStringArgument(ReadOnlySpan<char> arg)
+    {
+        StringOperation operation = StringOperation.None;
+
+        if (arg[0] == '*' && arg[^1] == '*') {
+            operation = StringOperation.Contains;
+        }
+        else if(arg[0] == '*') {
+            operation = StringOperation.EndsWith;
+        }
+        else if(arg[^1] == '*') {
+            operation = StringOperation.StartsWith;
+        }
+
+        arg = arg.TrimStart('*').TrimEnd('*');
+
+        if (arg[0] == '\'' && arg[^1] == '\'') {
+            return new StringArgument(arg[1..^1].ToString(), operation);
+        }
+
+        throw new ArgumentException("Invalid string");
+    }
+
+}

src/DistIL/IR/DSL/OutputPattern.cs

@@ -0,0 +1,48 @@
+namespace DistIL.IR.DSL;
+
+public readonly struct OutputPattern
+{
+    private readonly Dictionary<string, Value> _outputs = [];
+    private readonly Dictionary<string, Value> _buffer = [];
+    internal readonly InstructionPattern? Pattern = null;
+
+    public OutputPattern(ReadOnlySpan<char> input)
+    {
+        Pattern = InstructionPattern.Parse(input) as InstructionPattern;
+    }
+
+    internal void Add(string key, Value value)
+    {
+        _outputs[key] = value;
+    }
+
+    internal void AddToBuffer(string key, Value value)
+    {
+        _buffer[key] = value;
+    }
+
+    public Value this[string name] => _outputs[name];
+
+    public Value this[int position] {
+        get {
+            string name = _outputs.Keys.ElementAt(position);
+
+            return _outputs[name];
+        }
+    }
+
+    internal Value GetFromBuffer(string name)
+    {
+        return _buffer[name];
+    }
+
+    internal Value? Get(string name)
+    {
+        return _buffer.TryGetValue(name, out Value? value) ? value : _outputs.GetValueOrDefault(name);
+    }
+
+    internal bool IsValueInBuffer(string name)
+    {
+        return _buffer.ContainsKey(name);
+    }
+}

src/DistIL/IR/DSL/PatternArguments/BufferArgument.cs

@@ -0,0 +1,3 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record BufferArgument(string Name) : IInstructionPatternArgument;

src/DistIL/IR/DSL/PatternArguments/EvalArgument.cs

@@ -0,0 +1,3 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record EvalArgument(IInstructionPatternArgument OP) : IInstructionPatternArgument;

src/DistIL/IR/DSL/PatternArguments/IgnoreArgument.cs

@@ -0,0 +1,6 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record IgnoreArgument : IInstructionPatternArgument
+{
+
+}

src/DistIL/IR/DSL/PatternArguments/MethodRefArgument.cs

@@ -0,0 +1,3 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record MethodRefArgument(string Selector) : IInstructionPatternArgument;

src/DistIL/IR/DSL/PatternArguments/NotArgument.cs

@@ -0,0 +1,6 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record NotArgument(IInstructionPatternArgument Inner) : IInstructionPatternArgument
+{
+
+}

src/DistIL/IR/DSL/PatternArguments/NumberArgument.cs

@@ -0,0 +1,6 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record ConstantArgument(object Value, TypeDesc? Type) : IInstructionPatternArgument
+{
+
+}

src/DistIL/IR/DSL/PatternArguments/NumberOperatorArgument.cs

@@ -0,0 +1,6 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record NumberOperatorArgument(char Operator, IInstructionPatternArgument Argument) : IInstructionPatternArgument
+{
+
+}

src/DistIL/IR/DSL/PatternArguments/OutputArgument.cs

@@ -0,0 +1,6 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record OutputArgument(string Name, IInstructionPatternArgument? SubPattern = null) : IInstructionPatternArgument
+{
+
+}

src/DistIL/IR/DSL/PatternArguments/StringArgument.cs

@@ -0,0 +1,6 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal record StringArgument(object Value, StringOperation Operation) : ConstantArgument(Value, PrimType.String)
+{
+
+}

src/DistIL/IR/DSL/PatternArguments/StringOperation.cs

@@ -0,0 +1,9 @@
+namespace DistIL.IR.DSL.PatternArguments;
+
+internal enum StringOperation
+{
+    None,
+    StartsWith,
+    EndsWith,
+    Contains
+}