Add fallback support for legacy keywords

Earlier versions of the scripting package supported case-invariant
predefined type names. To avoid breaking changes we introduce here an
exception fallback path which scans the expression for these known type
identifiers and replaces them with the corresponding built-in type
keyword.

Author: glopesdev

src/Bonsai.Scripting.Expressions/CompatibilityAnalyzer.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Linq.Dynamic.Core;
+using System.Linq.Dynamic.Core.Tokenizer;
+using System.Text;
+
+namespace Bonsai.Scripting.Expressions
+{
+    internal static class CompatibilityAnalyzer
+    {
+        internal static readonly Dictionary<string, string> LegacyKeywords = new()
+        {
+            { "boolean", "bool" },
+            { "single", "float" },
+            { "int32", "int" },
+            { "int64", "long" },
+            { "int16", "short" },
+            { "uint32", "uint" },
+            { "uint64", "ulong" },
+            { "uint16", "ushort" },
+            { "math", "Math" },
+            { "convert", "Convert" }
+        };
+
+        public static bool ReplaceLegacyKeywords(ParsingConfig? parsingConfig, string text, out string result)
+        {
+            result = text;
+            if (string.IsNullOrEmpty(text))
+                return false;
+
+
+            List<(Token, string)> replacements = null;
+            var previousTokenId = TokenId.Unknown;
+            var textParser = new TextParser(parsingConfig, text);
+            while (textParser.CurrentToken.Id != TokenId.End)
+            {
+                if (textParser.CurrentToken.Id == TokenId.Identifier &&
+                    previousTokenId != TokenId.Dot &&
+                    LegacyKeywords.TryGetValue(textParser.CurrentToken.Text, out var keyword))
+                {
+                    replacements ??= new();
+                    replacements.Add((textParser.CurrentToken, keyword));
+                }
+
+                previousTokenId = textParser.CurrentToken.Id;
+                textParser.NextToken();
+            }
+
+            if (replacements?.Count > 0)
+            {
+                var sb = new StringBuilder(text);
+                for (int i = 0; i < replacements.Count; i++)
+                {
+                    var (token, keyword) = replacements[i];
+                    sb.Remove(token.Pos, token.Text.Length);
+                    sb.Insert(token.Pos, keyword);
+                }
+
+                result = sb.ToString();
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

src/Bonsai.Scripting.Expressions/DynamicExpressionHelper.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Linq.Dynamic.Core;
+using System.Linq.Dynamic.Core.Exceptions;
+using System.Linq.Expressions;
+
+namespace Bonsai.Scripting.Expressions
+{
+    internal class DynamicExpressionHelper
+    {
+        public static LambdaExpression ParseLambda(Type delegateType, ParsingConfig? parsingConfig, ParameterExpression[] parameters, Type? resultType, string expression, params object?[] values)
+        {
+            return ParseLambda(delegateType, parsingConfig, true, parameters, resultType, expression, values);
+        }
+
+        public static LambdaExpression ParseLambda(ParsingConfig? parsingConfig, Type itType, Type? resultType, string expression, params object?[] values)
+        {
+            return ParseLambda(null, parsingConfig, true, new[] { Expression.Parameter(itType, "it") }, resultType, expression, values);
+        }
+
+        public static LambdaExpression ParseLambda(Type? delegateType, ParsingConfig? parsingConfig, bool createParameterCtor, ParameterExpression[] parameters, Type? resultType, string expression, params object?[] values)
+        {
+            try
+            {
+                return DynamicExpressionParser.ParseLambda(delegateType, parsingConfig, createParameterCtor, parameters, resultType, expression, values);
+            }
+            catch (ParseException)
+            {
+                if (!CompatibilityAnalyzer.ReplaceLegacyKeywords(parsingConfig, expression, out expression))
+                    throw;
+
+                return DynamicExpressionParser.ParseLambda(delegateType, parsingConfig, createParameterCtor, parameters, resultType, expression, values);
+            }
+        }
+    }
+}

src/Bonsai.Scripting.Expressions/ExpressionCondition.cs

@@ -54,7 +54,7 @@ public override Expression Build(IEnumerable<Expression> arguments)
             var source = arguments.First();
             var sourceType = source.Type.GetGenericArguments()[0];
             var config = ParsingConfigHelper.CreateParsingConfig(sourceType);
-            var predicate = DynamicExpressionParser.ParseLambda(config, sourceType, typeof(bool), Expression);
+            var predicate = DynamicExpressionHelper.ParseLambda(config, sourceType, typeof(bool), Expression);
             return System.Linq.Expressions.Expression.Call(whereMethod.MakeGenericMethod(sourceType), source, predicate);
         }
 

src/Bonsai.Scripting.Expressions/ExpressionSink.cs

@@ -61,7 +61,7 @@ public override Expression Build(IEnumerable<Expression> arguments)
                 var actionType = System.Linq.Expressions.Expression.GetActionType(sourceType);
                 var itParameter = new[] { System.Linq.Expressions.Expression.Parameter(sourceType, string.Empty) };
                 var config = ParsingConfigHelper.CreateParsingConfig(sourceType);
-                var onNext = DynamicExpressionParser.ParseLambda(actionType, config, itParameter, null, Expression);
+                var onNext = DynamicExpressionHelper.ParseLambda(actionType, config, itParameter, null, Expression);
                 return System.Linq.Expressions.Expression.Call(doMethod.MakeGenericMethod(sourceType), source, onNext);
             }
             else return source;

src/Bonsai.Scripting.Expressions/ExpressionTransform.cs

@@ -55,7 +55,7 @@ public override Expression Build(IEnumerable<Expression> arguments)
             var source = arguments.First();
             var sourceType = source.Type.GetGenericArguments()[0];
             var config = ParsingConfigHelper.CreateParsingConfig(sourceType);
-            var selector = DynamicExpressionParser.ParseLambda(config, sourceType, null, Expression);
+            var selector = DynamicExpressionHelper.ParseLambda(config, sourceType, null, Expression);
             return System.Linq.Expressions.Expression.Call(selectMethod.MakeGenericMethod(sourceType, selector.ReturnType), source, selector);
         }