Add single dimensional array support

Author: Rajesh Jinaga

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.Helpers.cs

@@ -44,24 +44,6 @@ private string GetUnquotedText(string @string)
             return @string.Substring(1, @string.Length - 2); // Trim first and last quotes
         }
 
-        private Expression GetEndProperty(Expression rootObjectExp, string[] propertiesHierarchy, int startIndex = 0)
-        {
-            for (int index = startIndex; index < propertiesHierarchy.Length; index++)
-            {
-                var propertyName = propertiesHierarchy[index];
-                var prop = GetPropertyInfo(rootObjectExp.Type, propertyName);
-
-                if (prop == null)
-                {
-                    throw new InvalidPropertyException($"Invalid property '{propertyName}'");
-                }
-
-                rootObjectExp = Expression.Property(rootObjectExp, prop);
-            }
-
-            return rootObjectExp;
-        }
-
         private ParameterExpression GetVariable(string name)
         {
            return  Variables.SingleOrDefault(@var => string.Equals(@var.Name , name, StringComparison.OrdinalIgnoreCase));

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.VisitArray.cs

@@ -0,0 +1,62 @@
+// Copyright (c) navtech.io. All rights reserved.
+// See License in the project root for license information.
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Antlr4.Runtime.Misc;
+
+using Simpleflow.Parser;
+
+namespace Simpleflow.CodeGenerator
+{
+    partial class SimpleflowCodeVisitor<TArg>
+    {
+        public override Expression VisitArrayLiteral([NotNull] SimpleflowParser.ArrayLiteralContext context)
+        {
+            var arrayValue = context.arrayValue();
+            var ilArrayValue = new List<Expression>(arrayValue.Length);
+            Type ilArrayType = null;
+
+            // process each value in array
+            foreach (var value in arrayValue)
+            {
+                var ilexp = value.Accept(this);
+                if (ilexp != null)
+                {
+                    ilArrayValue.Add(ilexp);
+
+                    // Check for type, if type is not matched with previous one then consider it as array of objects
+                    if (ilArrayType != null && ilArrayType != ilexp.Type)
+                    {
+                        ilArrayType = typeof(object);
+                    }
+                    else
+                    {
+                        ilArrayType = ilexp.Type;
+                    }
+                }
+            }
+
+            ilArrayType = ilArrayType ?? typeof(object); // This assignment if no values in array
+
+            // Convert all of the expressions into object expressions if all the types are not same
+            if (ilArrayType == typeof(object))
+            {
+                ilArrayValue = ilArrayValue.Select(item => Expression.Convert(item, typeof(object))).ToList<Expression>();
+            }
+
+            // Create list object
+            var constructorInfo = typeof(List<>).MakeGenericType(ilArrayType)
+                                                .GetConstructor(new Type[] { typeof(IEnumerable<>).MakeGenericType(ilArrayType) });
+
+            return Expression.New(constructorInfo, Expression.NewArrayInit(ilArrayType, ilArrayValue));
+        }
+
+        public override Expression VisitArrayValue([NotNull] SimpleflowParser.ArrayValueContext context)
+        {
+            return Visit(context.GetChild(0));
+        }
+    }
+}

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.VisitEmitters.cs

@@ -58,28 +58,6 @@ public override Expression VisitOutputStmt(SimpleflowParser.OutputStmtContext co
             return callExpr;
         }
 
-
-        /// <summary>
-        ///  Trim first and last quotes
-        /// </summary>
-        /// <param name="string"></param>
-        /// <returns></returns>
-      
-
-        private Expression CallListAddMethod(Expression message, string propertyName)
-        {
-
-            Expression callExpr = Expression.Call(
-                Expression.Property(OutputParam, propertyName),
-                // ReSharper disable once AssignNullToNotNullAttribute
-                typeof(List<string>).GetMethod(nameof(List<string>.Add), new Type[] { typeof(string) }),
-                message
-            );
-
-            // Call function to to add message 
-            return callExpr;
-        }
-
         private Expression HandleMessageText(SimpleflowParser.MessageTextContext messageToken, string outputProperty)
         {
             var identifier = Visit(messageToken.GetChild(0));
@@ -88,9 +66,19 @@ private Expression HandleMessageText(SimpleflowParser.MessageTextContext message
                          identifier : ToStringExpression(identifier);
 
             return CallListAddMethod(identifier, outputProperty);
-
         }
 
+        private Expression CallListAddMethod(Expression message, string outputProperty)
+        {
+            Expression callExpr = Expression.Call(
+                Expression.Property(OutputParam, outputProperty),
+                // ReSharper disable once AssignNullToNotNullAttribute
+                typeof(List<string>).GetMethod(nameof(List<string>.Add), new Type[] { typeof(string) }),
+                message
+            );
 
+            // Call function to add message 
+            return callExpr;
+        }
     }
 }

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.VisitObjectIdentifier.cs

@@ -1,12 +1,9 @@
 // Copyright (c) navtech.io. All rights reserved.
 // See License in the project root for license information.
 
-using System;
 using System.Linq;
 using System.Linq.Expressions;
 
-using Antlr4.Runtime.Tree;
-
 using Simpleflow.Exceptions;
 using Simpleflow.Parser;
 
@@ -16,17 +13,63 @@ partial class SimpleflowCodeVisitor<TArg>
     {
         public override Expression VisitObjectIdentifier(SimpleflowParser.ObjectIdentifierContext context)
         {
-            var objectPathProperties = context.GetText().Split('.');
-            
-            var propName = objectPathProperties[0];
-            Expression identifier = GetVariable(propName) ?? GetSmartVariable(propName)?.VariableExpression?.Left;
+            // Get initial object
+            var variableName = context.identifierIndex()[0].Identifier().GetText();
+            Expression objectExp = GetVariable(variableName) ?? GetSmartVariable(variableName)?.VariableExpression?.Left;
 
-            if (identifier == null)
+            if (objectExp == null)
             {
-                throw new UndeclaredVariableException(objectPathProperties[0]);
+                throw new UndeclaredVariableException(variableName);
+            }
+
+            // Get index object if specified
+            var indexObjectExp = GetIndexObjectExpIfDefined(objectExp, context.identifierIndex()[0]);
+
+            // Traverse through and get final object
+            return GetFinalPropertyValue(indexObjectExp, context.identifierIndex());
+        }
+
+        private Expression GetIndexObjectExpIfDefined(Expression objectExp, SimpleflowParser.IdentifierIndexContext context)
+        {
+            if (context.index() != null)
+            {
+                var indexExpression = Visit(context.index().indexExpression().GetChild(0)); // represents index 
+
+                var indexProperty
+                    = objectExp
+                        .Type
+                        .GetProperties()
+                        .SingleOrDefault(p => p.GetIndexParameters().Length == 1 &&
+                                              p.GetIndexParameters()[0].ParameterType == indexExpression.Type);
+                
+                return Expression.MakeIndex(objectExp, indexProperty, new[] { indexExpression });
             }
 
-            return GetEndProperty(identifier, objectPathProperties, startIndex: 1);
+            return objectExp;
+        }
+
+        private Expression GetFinalPropertyValue(Expression propExp, SimpleflowParser.IdentifierIndexContext[] propertiesHierarchy)
+        {
+            for (int i = 1; i < propertiesHierarchy.Length; i++)
+            {
+                var property = propertiesHierarchy[i];
+
+                // Get next property name
+                var propName = property.Identifier().GetText();
+                var prop = GetPropertyInfo(propExp.Type, propName);
+
+                if (prop == null)
+                {
+                    throw new InvalidPropertyException($"Invalid property '{propName}'");
+                }
+
+                // Get indexed object
+                propExp = GetIndexObjectExpIfDefined(propExp, property);
+
+                // Get property of indexed object
+                propExp = Expression.Property(propExp, prop);
+            }
+            return propExp;
         }
     }
 }

src/Simpleflow/CodeGenerator/SimpleflowCodeVisitor.VisitRule.cs

@@ -21,11 +21,9 @@ public override Expression VisitRuleStmt(SimpleflowParser.RuleStmtContext contex
             var statements = new List<Expression>();
 
             // Process predicate and statements
-            for (int i = 0; i < context.ChildCount; i++)
+            foreach (var statement in context.generalStatement())
             {
-                var c = context.GetChild(i);
-
-                // Stop at end statement and return block outside of if else
+                var c = statement. GetChild(0);
 
                 if (c.GetType() != typeof(SimpleflowParser.PredicateContext))
                 {
@@ -38,6 +36,5 @@ public override Expression VisitRuleStmt(SimpleflowParser.RuleStmtContext contex
             }
             return Expression.IfThen(testExpression, Expression.Block(statements));
         }
-
     }
 }

src/Simpleflow/Parser/Base/SimpleflowParserBase.cs

@@ -23,6 +23,22 @@ protected SimpleflowParserBase(ITokenStream input, TextWriter output, TextWriter
         {
         }
 
+        protected bool NotLineTerminator()
+        {
+            return !Here(LineTerminator);
+        }
+
+        protected bool Here(int type)
+        {
+            // Get the token ahead of the current index.
+            int possibleIndexEosToken = CurrentToken.TokenIndex - 1;
+            IToken ahead = ((ITokenStream)this.InputStream).Get(possibleIndexEosToken);
+
+            // Check if the token resides on the Hidden channel and if it's of the
+            // provided type.
+            return ahead.Channel == Lexer.Hidden && ahead.Type == type;
+        }
+
         protected bool LineTerminatorAhead()
         {
             // Get the token ahead of the current index.

src/Simpleflow/Parser/Grammar/SimpleflowLexer.g4

@@ -3,16 +3,16 @@ lexer grammar SimpleflowLexer;
 channels { ERROR }
 options { superClass=SimpleflowLexerBase; }
 
-WhiteSpaces:        [\t\u000B\u000C\u0020\u00A0]+ -> channel(HIDDEN);
-LineTerminator:     [\r\n\u2028\u2029] -> channel(HIDDEN);
 MultiLineComment:   '/*' .*? '*/'  -> channel(HIDDEN);
 SingleLineComment:  '#' ~[\r\n\u2028\u2029]*  -> channel(HIDDEN);
 
+OpenBracket:        '[';
+CloseBracket:       ']';
+OpenParen:          '(';
+CloseParen:         ')'; 
 OpenBrace:          '{';
 TemplateCloseBrace: {this.IsInTemplateString()}? '}' -> popMode;
 CloseBrace:         '}';
-OpenParen:          '(';
-CloseParen:         ')'; 
 
 Colon:              ':' ;
 Comma :             ',';
@@ -34,7 +34,6 @@ LessThan:           '<';
 LessThanEqual:      '<=';
 Equal:              '==';
 NotEqual:           '!=';
-Contains:           'contains';
 
 // keywords
 
@@ -55,6 +54,8 @@ Output:             'output';
 
 // relational operators
 
+Semicolon: ';';
+
 And:                'and';
 Or:                 'or';
 Not:                'not';
@@ -63,15 +64,21 @@ Not:                'not';
 True:               'true';
 False:              'false';
 Number:             ('+'|'-')?[0-9]+('.'[0-9]+)?;
+ 
 String:             '"' ( '\\"' | ~["\r\n] )*? '"';
 None:               'none' ;
 
 Identifier:         [_]*[a-zA-Z][_a-zA-Z0-9]* ;
 IgnoreIdentifier:  '_';
 
+Indexer:             OpenBracket Number CloseBracket;
+
 FunctionName:       '$' NAME ('.' NAME)*;
 BackTick:           '`' {this.IncreaseTemplateDepth();} -> pushMode(TEMPLATE);
 
+WhiteSpaces:        [\t\u000B\u000C\u0020\u00A0]+ -> channel(HIDDEN);
+LineTerminator:     [\r\n\u2028\u2029] -> channel(HIDDEN);
+
 mode TEMPLATE;
 
 BackTickInside:                 '`' {this.DecreaseTemplateDepth();} -> type(BackTick), popMode;