ref keyword ok + inline init

Author: codingseb

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -2285,5 +2285,91 @@ public void MethodWithOutParameterInlineVarDeclaration()
         }
 
         #endregion
+
+        #region Method with ref parameter
+
+        [Test]
+        [Category("RefKeywordMethod")]
+        public void MethodWithRefParameter()
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator();
+
+            evaluator.Variables["refObj"] = new MethodArgKeywordClass();
+
+            evaluator.Variables["x"] = 3;
+
+            evaluator.Evaluate("refObj.AddOneOnRef(ref x)");
+
+            evaluator.Variables.ShouldContainKey("x");
+            evaluator.Variables["x"]
+                .ShouldBeOfType<int>()
+                .ShouldBe(4);
+        }
+
+        [Test]
+        [Category("RefKeywordMethod")]
+        public void MethodWithRefParameterWithoutExistingVariable()
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator();
+
+            evaluator.Variables["refObj"] = new MethodArgKeywordClass();
+
+            evaluator.Evaluate("refObj.AddOneOnRef(ref x)");
+
+            evaluator.Variables.ShouldContainKey("x");
+            evaluator.Variables["x"]
+                .ShouldBeOfType<int>()
+                .ShouldBe(1);
+        }
+
+        [Test]
+        [Category("RefKeywordMethod")]
+        public void MethodWithRefParameterInlineVarDeclaration()
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator();
+
+            evaluator.Variables["refObj"] = new MethodArgKeywordClass();
+
+            evaluator.Evaluate("refObj.AddOneOnRef(ref int x)");
+
+            evaluator.Variables.ShouldContainKey("x");
+            evaluator.Variables["x"]
+                .ShouldBeOfType<StronglyTypedVariable>()
+                .Value.ShouldBe(1);
+        }
+
+        [Test]
+        [Category("RefKeywordMethod")]
+        public void MethodWithRefParameterWithoutExistingVariableAndInit()
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator();
+
+            evaluator.Variables["refObj"] = new MethodArgKeywordClass();
+
+            evaluator.Evaluate("refObj.AddOneOnRef(ref x = 4)");
+
+            evaluator.Variables.ShouldContainKey("x");
+            evaluator.Variables["x"]
+                .ShouldBeOfType<int>()
+                .ShouldBe(5);
+        }
+
+        [Test]
+        [Category("RefKeywordMethod")]
+        public void MethodWithRefParameterInlineVarDeclarationAndInit()
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator();
+
+            evaluator.Variables["refObj"] = new MethodArgKeywordClass();
+
+            evaluator.Evaluate("refObj.AddOneOnRef(ref int x = 6)");
+
+            evaluator.Variables.ShouldContainKey("x");
+            evaluator.Variables["x"]
+                .ShouldBeOfType<StronglyTypedVariable>()
+                .Value.ShouldBe(7);
+        }
+
+        #endregion
     }
 }

CodingSeb.ExpressionEvaluator.Tests/TestsUtils/MethodArgKeywordClass.cs

@@ -0,0 +1,10 @@
+namespace CodingSeb.ExpressionEvaluator.Tests
+{
+    public class MethodArgKeywordClass
+    {
+        public void AddOneOnRef(ref int i)
+        {
+            i++;
+        }
+    }
+}

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -53,7 +53,7 @@ public partial class ExpressionEvaluator
         protected static readonly Regex lambdaExpressionRegex = new Regex(@"^(?>\s*)(?<args>((?>\s*)[(](?>\s*)([\p{L}_](?>[\p{L}_0-9]*)(?>\s*)([,](?>\s*)[\p{L}_][\p{L}_0-9]*(?>\s*))*)?[)])|[\p{L}_](?>[\p{L}_0-9]*))(?>\s*)=>(?<expression>.*)$", RegexOptions.Singleline | RegexOptions.Compiled);
         protected static readonly Regex lambdaArgRegex = new Regex(@"[\p{L}_](?>[\p{L}_0-9]*)", RegexOptions.Compiled);
         protected static readonly Regex initInNewBeginningRegex = new Regex(@"^(?>\s*){", RegexOptions.Compiled);
-        protected static readonly Regex functionArgKeywordsRegex = new Regex(@"^\s*(?<keyword>out|ref)\s+((?<typeName>[\p{L}_][\p{L}_0-9\.\[\]<>]*[?]?)\s+(?=[\p{L}_]))?(?<varName>[\p{L}_](?>[\p{L}_0-9]*))", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+        protected static readonly Regex functionArgKeywordsRegex = new Regex(@"^\s*(?<keyword>out|ref)\s+((?<typeName>[\p{L}_][\p{L}_0-9\.\[\]<>]*[?]?)\s+(?=[\p{L}_]))?(?<toEval>(?<varName>[\p{L}_](?>[\p{L}_0-9]*))\s*(=.*)?)$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
 
         // Depending on OptionInlineNamespacesEvaluationActive. Initialized in constructor
         protected string InstanceCreationWithNewKeywordRegexPattern { get { return @"^new(?>\s*)((?<isAnonymous>[{{])|((?<name>[\p{L}_][\p{L}_0-9"+ (OptionInlineNamespacesEvaluationActive ? @"\." : string.Empty) + @"]*)(?>\s*)(?<isgeneric>[<](?>[^<>]+|(?<gentag>[<])|(?<-gentag>[>]))*(?(gentag)(?!))[>])?(?>\s*)((?<isfunction>[(])|(?<isArray>\[)|(?<isInit>[{{]))?))"; } }
@@ -1919,7 +1919,7 @@ protected virtual bool EvaluateVarOrFunc(string expression, Stack<object> stack,
                                                 variables[outOrRefArg.VariableName] = null;
                                             }
 
-                                            argValue = Evaluate(outOrRefArg.VariableName);
+                                            argValue = Evaluate(functionArgKeywordsMatch.Groups["toEval"].Value);
                                         }
                                         else
                                         {