Fixed compiling of constructor and type reference. Fixed unary plus/minus. Added node.getRaw().

src/SpelExpressionParser.js

@@ -714,7 +714,7 @@ export var SpelExpressionParser = function () {
             return true;
         }
         var value = node.stringValue();
-        return (value.length && VALID_QUALIFIED_ID_PATTERN.test(value));
+        return (value && value.length && VALID_QUALIFIED_ID_PATTERN.test(value));
     }
 
     // This is complicated due to the support for dollars in identifiers.  Dollars are normally separate tokens but

src/ast/BeanReference.js

@@ -22,8 +22,8 @@ import {SpelNode} from './SpelNode';
  *
  * @author Andy Clement
  */
-function createNode(position, left, right) {
-    var node = SpelNode.create('beanref', position, left, right);
+function createNode(position, beanName) {
+    var node = SpelNode.create('beanref', position);
 
     node.getValue = function (state) {
         throw {

src/ast/ConstructorReference.js

@@ -15,6 +15,7 @@
  */
 
 import {SpelNode} from './SpelNode';
+import {Stack} from '../lib/Stack';
 
 /**
  * Represents the invocation of a constructor. Either a constructor on a regular type or
@@ -29,13 +30,51 @@ import {SpelNode} from './SpelNode';
  * @author Juergen Hoeller
  * @since 3.0
  */
-function createNode(position, left, right) {
-    var node = SpelNode.create('constructorref', position, left, right);
+ function createNode(position, dimensions, nodes) {
+    var isArray = nodes !== undefined;
+    var dimension;
+    if (isArray) {
+        dimension = dimensions.length && dimensions[0] && dimensions[0].getType() === 'number' ? dimensions[0].getValue() : null;
+    } else {
+        nodes = dimensions;
+        dimensions = undefined;
+    }
+    const [_qualifiedIdentifier, ...args] = nodes;
+
+    var node = SpelNode.create('constructorref', position, ...nodes);
+
+    node.getRaw = function () {
+        return dimension;
+    };
 
     node.getValue = function (state) {
+        if (isArray && args.length <= 1) {
+            var compiledArgs = [];
+
+            //populate arguments
+            args.forEach(function (arg) {
+                // reset the active context to root context for evaluating argument
+                const currentActiveContext = state.activeContext
+                state.activeContext = new Stack();
+                state.activeContext.push(state.rootContext);
+
+                // evaluate argument
+                compiledArgs.push(arg.getValue(state));
+
+                // reset the active context
+                state.activeContext = currentActiveContext;
+            });
+
+            if (args.length === 1) {
+                return compiledArgs[0];
+            } else {
+                return dimension ? new Array(dimension) : [];
+            }
+        }
+
         throw {
             name: 'MethodNotImplementedException',
-            message: 'BeanReference: Not implemented'
+            message: 'ConstructorReference: Not implemented'
         }
     };
 

src/ast/FunctionReference.js

@@ -36,6 +36,13 @@ import {Stack} from '../lib/Stack';
 function createNode(functionName, position, args) {
     var node = SpelNode.create('function', position);
 
+    node.getRaw = function () {
+        return {
+            functionName,
+            args
+        };
+    };
+
     node.getValue = function (state) {
         var locals = state.locals || {},
             context = state.rootContext,

src/ast/Identifier.js

@@ -22,8 +22,12 @@ import {SpelNode} from './SpelNode';
  * @author Andy Clement
  * @since 3.0
  */
-function createNode(position, left, right) {
-    var node = SpelNode.create('identifier', position, left, right);
+function createNode(identifierName, position) {
+    var node = SpelNode.create('identifier', position);
+
+    node.getRaw = function () {
+        return identifierName;
+    };
 
     node.getValue = function (state) {
         throw {

src/ast/InlineList.js

@@ -28,6 +28,10 @@ function createNode(position, elements) {
     var node = SpelNode.create('list', position),
         list = [].concat(elements || []);
 
+    node.getRaw = function () {
+        return list;
+    };
+
     node.getValue = function (state) {
         return list.map(function (element) {
             return element.getValue(state);

src/ast/MethodReference.js

@@ -30,6 +30,13 @@ import {Stack} from '../lib/Stack'
 function createNode(nullSafeNavigation, methodName, position, args) {
     var node = SpelNode.create('method', position);
 
+    node.getRaw = function () {
+        return {
+            methodName,
+            args
+        };
+    };
+
     node.getValue = function (state) {
         var context = state.activeContext.peek(),
             compiledArgs = [],

src/ast/OpMinus.js

@@ -39,6 +39,9 @@ function createNode(position, left, right) {
     var node = SpelNode.create('op-minus', position, left, right);
 
     node.getValue = function (state) {
+        if (!right) {
+            return - left.getValue(state);
+        }
         return left.getValue(state) - right.getValue(state);
     };
 

src/ast/OpPlus.js

@@ -39,6 +39,9 @@ function createNode(position, left, right) {
     var node = SpelNode.create('op-plus', position, left, right);
 
     node.getValue = function (state) {
+        if (!right) {
+            return + left.getValue(state);
+        }
         //javascript will handle string concatenation or addition depending on types
         return left.getValue(state) + right.getValue(state);
     };

src/ast/PropertyReference.js

@@ -29,6 +29,10 @@ import {SpelNode} from './SpelNode';
 function createNode(nullSafeNavigation, propertyName, position) {
     var node = SpelNode.create('property', position);
 
+    node.getRaw = function () {
+        return propertyName;
+    };
+
     node.getValue = function (state) {
         var context = state.activeContext.peek();
 

src/ast/QualifiedIdentifier.js

@@ -25,8 +25,12 @@ import {SpelNode} from './SpelNode';
  * @author Andy Clement
  * @since 3.0
  */
-function createNode(position, left, right) {
-    var node = SpelNode.create('qualifiedidentifier', position, left, right);
+function createNode(position, pieces) {
+    var node = SpelNode.create('qualifiedidentifier', position, ...pieces);
+
+    node.getRaw = function () {
+        return pieces.map(p => p.getRaw());
+    };
 
     node.getValue = function (state) {
         throw {

src/ast/SpelNode.js

@@ -43,6 +43,16 @@ function createSpelNode(nodeType, position, ...operands) {
         return children;
     };
     node.addChild = function (childNode) {
+        if (!childNode) {
+            // See OpMinus and OpPlus: right node can be null for unary mode
+            return;
+        }
+        if (!childNode.setParent) {
+            throw {
+                name: 'Error',
+                message: 'Trying to add a child which is not a node: ' + JSON.stringify(childNode)
+            };
+        }
         childNode.setParent(node);
         children.push(childNode);
     };

src/ast/TypeReference.js

@@ -22,8 +22,8 @@ import {SpelNode} from './SpelNode';
  *
  * @author Andy Clement
  */
-function createNode(position, left, right) {
-    var node = SpelNode.create('typeref', position, left, right);
+function createNode(position, node, _dims) {
+    var node = SpelNode.create('typeref', position, node);
 
     node.getValue = function (state) {
         throw {

src/ast/VariableReference.js

@@ -28,6 +28,10 @@ import {SpelNode} from './SpelNode';
 function createNode(variableName, position) {
     var node = SpelNode.create('variable', position);
 
+    node.getRaw = function () {
+        return variableName;
+    };
+
     node.getValue = function (state) {
         var context = state.activeContext.peek(),
             locals = state.locals;

test/spec/SpelExpressionEvaluator.spec.js

@@ -17,6 +17,38 @@ describe('spel expression evaluator', ()=>{
             expect(compiledExpression.eval).toBeDefined();
         });
 
+        it('should compile expression with constructor', ()=>{
+            //when
+            let compiledExpression = evaluator.compile('new java.text.SimpleDateFormat("yyyy-MM-dd").parse("2022-01-01")');
+
+            //then
+            expect(compiledExpression.eval).toBeDefined();
+        });
+
+        it('should compile expression with array constructor without dimensions', ()=>{
+            //when
+            let compiledExpression = evaluator.compile('new int[]{1,2,3}');
+
+            //then
+            expect(compiledExpression.eval).toBeDefined();
+        });
+
+        it('should compile expression with array constructor with dimensions', ()=>{
+            //when
+            let compiledExpression = evaluator.compile('new int[3]{1,2,3}');
+
+            //then
+            expect(compiledExpression.eval).toBeDefined();
+        });
+
+        it('should compile expression with type reference', ()=>{
+            //when
+            let compiledExpression = evaluator.compile('T(java.time.LocalTime).parse("11:22")');
+
+            //then
+            expect(compiledExpression.eval).toBeDefined();
+        });
+
     });
 
 
@@ -28,10 +60,14 @@ describe('spel expression evaluator', ()=>{
                 //when
                 let numberInt = evaluator.eval('123');
                 let numberFloat = evaluator.eval('123.4');
+                let negativeNumberInt = evaluator.eval('-123');
+                let negativeNumberFloat = evaluator.eval('-123.4');
 
                 //then
                 expect(numberInt).toBe(123);
                 expect(numberFloat).toBe(123.4);
+                expect(negativeNumberInt).toBe(-123);
+                expect(negativeNumberFloat).toBe(-123.4);
             });
 
             it('should evaluate a string', ()=>{
@@ -833,6 +869,52 @@ describe('spel expression evaluator', ()=>{
 
         });
 
+        describe('constructor', ()=>{
+            it('should create new int array', ()=>{
+                //given
+                let context = {};
+
+                //when
+                let newArray = evaluator.eval('new int[]{1, 2, 3}', context);
+
+                //then
+                expect(newArray).toEqual([1, 2, 3]);
+            });
+
+            it('should create new int array with dimension', ()=>{
+                //given
+                let context = {};
+
+                //when
+                let newArray = evaluator.eval('new int[3]{1, 2, 3}', context);
+
+                //then
+                expect(newArray).toEqual([1, 2, 3]);
+            });
+
+            it('should create new empty array', ()=>{
+                //given
+                let context = {};
+
+                //when
+                let newArray = evaluator.eval('new int[]', context);
+
+                //then
+                expect(newArray).toEqual([]);
+            });
+
+            it('should create new empty array with dimension', ()=>{
+                //given
+                let context = {};
+
+                //when
+                let newArray = evaluator.eval('new int[3]', context);
+
+                //then
+                expect(newArray.length).toEqual(3);
+            });
+        });
+
     });
 
 });