Correction of #127 new instance when OptionInlineNamespacesEvaluationActive is false

Author: codingseb

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -1591,6 +1591,53 @@ public void ExceptionThrowingEvaluation(ExpressionEvaluator evaluator, string ex
 
         #region Bug corrections
 
+        /// <summary>
+        /// To correct #127 Evaluating "new DateTime(2022,1,20)" does not work 
+        /// unless OptionInlineNamespacesEvaluationActive is turned on
+        /// </summary>
+        [Test]
+        [Category("Bug")]
+        [Category("#127")]
+        public void Evaluate_NewDateTime_When_OptionInlineNamespacesEvaluationActive_is_off()
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator()
+            {
+                OptionInlineNamespacesEvaluationActive = false,
+            };
+
+            DateTime? dateTime = evaluator.Evaluate<DateTime>("new DateTime(2022,1,20)");
+
+            dateTime.HasValue.ShouldBeTrue();
+
+            dateTime.Value.Year.ShouldBe(2022);
+            dateTime.Value.Month.ShouldBe(1);
+            dateTime.Value.Day.ShouldBe(20);
+        }
+
+        /// <summary>
+        /// To correct #127 Evaluating "new DateTime(2022,1,20)" does not work 
+        /// unless OptionInlineNamespacesEvaluationActive is turned on
+        /// </summary>
+        [Test]
+        [Category("Bug")]
+        [Category("#127")]
+        public void Evaluate_NewDateTime_When_OptionInlineNamespacesEvaluationActive_is_on()
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator()
+            {
+                OptionInlineNamespacesEvaluationActive = true,
+            };
+
+            DateTime? dateTime = evaluator.Evaluate<DateTime>("new DateTime(2022,1,20)");
+
+            dateTime.HasValue.ShouldBeTrue();
+
+            dateTime.Value.Year.ShouldBe(2022);
+            dateTime.Value.Month.ShouldBe(1);
+            dateTime.Value.Day.ShouldBe(20);
+        }
+
+
         /// <summary>
         /// To correct #81 Exception is assigned to variable
         /// With simple variable

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -2509,32 +2509,61 @@ protected virtual Type EvaluateType(string expression,ref int i, string currentN
             Type staticType = GetTypeByFriendlyName(typeName, genericsTypes);
 
             // For inline namespace parsing
-            if (staticType == null && OptionInlineNamespacesEvaluationActive)
+            if (staticType == null)
             {
-                int subIndex = 0;
-                Match namespaceMatch = varOrFunctionRegEx.Match(expression.Substring(i + subIndex));
-
-                while (staticType == null
-                    && namespaceMatch.Success
-                    && !namespaceMatch.Groups["sign"].Success
-                    && !namespaceMatch.Groups["assignationOperator"].Success
-                    && !namespaceMatch.Groups["postfixOperator"].Success
-                    && !namespaceMatch.Groups["isfunction"].Success
-                    && i + subIndex < expression.Length
-                    && !typeName.EndsWith("?"))
+                if (OptionInlineNamespacesEvaluationActive)
                 {
-                    subIndex += namespaceMatch.Length;
-                    typeName += $"{namespaceMatch.Groups["inObject"].Value}{namespaceMatch.Groups["name"].Value}{((i + subIndex < expression.Length && expression.Substring(i + subIndex)[0] == '?') ? "?" : "") }";
+                    int subIndex = 0;
+                    Match namespaceMatch = varOrFunctionRegEx.Match(expression.Substring(i + subIndex));
+
+                    while (staticType == null
+                        && namespaceMatch.Success
+                        && !namespaceMatch.Groups["sign"].Success
+                        && !namespaceMatch.Groups["assignationOperator"].Success
+                        && !namespaceMatch.Groups["postfixOperator"].Success
+                        && !namespaceMatch.Groups["isfunction"].Success
+                        && i + subIndex < expression.Length
+                        && !typeName.EndsWith("?"))
+                    {
+                        subIndex += namespaceMatch.Length;
+                        typeName += $"{namespaceMatch.Groups["inObject"].Value}{namespaceMatch.Groups["name"].Value}{((i + subIndex < expression.Length && expression.Substring(i + subIndex)[0] == '?') ? "?" : "") }";
 
-                    staticType = GetTypeByFriendlyName(typeName, namespaceMatch.Groups["isgeneric"].Value);
+                        staticType = GetTypeByFriendlyName(typeName, namespaceMatch.Groups["isgeneric"].Value);
 
-                    if (staticType != null)
-                    {
-                        i += subIndex;
-                        break;
+                        if (staticType != null)
+                        {
+                            i += subIndex;
+                            break;
+                        }
+
+                        namespaceMatch = varOrFunctionRegEx.Match(expression.Substring(i + subIndex));
                     }
+                }
+                else
+                {
+                    int subIndex = 0;
+                    Match typeMatch = varOrFunctionRegEx.Match(expression.Substring(i + subIndex));
+
+                    if (staticType == null
+                        && typeMatch.Success
+                        && !typeMatch.Groups["sign"].Success
+                        && !typeMatch.Groups["assignationOperator"].Success
+                        && !typeMatch.Groups["postfixOperator"].Success
+                        && !typeMatch.Groups["isfunction"].Success
+                        && !typeMatch.Groups["inObject"].Success
+                        && i + subIndex < expression.Length
+                        && !typeName.EndsWith("?"))
+                    {
+                        subIndex += typeMatch.Length;
+                        typeName += $"{typeMatch.Groups["name"].Value}{((i + subIndex < expression.Length && expression.Substring(i + subIndex)[0] == '?') ? "?" : "") }";
 
-                    namespaceMatch = varOrFunctionRegEx.Match(expression.Substring(i + subIndex));
+                        staticType = GetTypeByFriendlyName(typeName, typeMatch.Groups["isgeneric"].Value);
+
+                        if (staticType != null)
+                        {
+                            i += subIndex;
+                        }
+                    }
                 }
             }