public void ArrayExpressionCreatesEmptyArrayExpression()
{
var a = new ArrayExpression();
Assert.IsNotNull(a);
Assert.IsNotNull(a.Elements);
Assert.AreEqual(0, a.Elements.Count);
Assert.AreEqual("[];", a.ToString());
}
public void CanCreateArrayExpressionWithIEnumerable()
{
var list = new List<Expression> { 1, 2, 3 };
var a = new ArrayExpression(list);
Assert.IsNotNull(a);
Assert.IsNotNull(a.Elements);
Assert.AreEqual(3, a.Elements.Count);
Assert.AreEqual("[1,2,3];", a.ToString());
}
public void CanCompareArrayExpressions()
{
var a = new ArrayExpression(1, 2, 3);
var b = new ArrayExpression(1, 2, 3);
var c = new ArrayExpression(4, 5, 6);
Assert.IsNotNull(a);
Assert.IsNotNull(b);
Assert.IsNotNull(c);
Assert.IsTrue(Equals(a,b));
Assert.IsFalse(Equals(a, c));
}
public void CanAddExpressionsToArrayExpression()
{
var a = new ArrayExpression();
a.Elements.Add(1);
a.Elements.Add(2);
a.Elements.Add(3);
Assert.IsNotNull(a);
Assert.IsNotNull(a.Elements);
Assert.AreEqual(3, a.Elements.Count);
Assert.AreEqual("[1,2,3];", a.ToString());
}
public void ArrayExpressionHasHashCode()
{
var a = new ArrayExpression(1, 2, 3);
var b = new ArrayExpression(1, 2, 3);
var c = new ArrayExpression(4, 5, 6);
Assert.IsNotNull(a);
Assert.IsNotNull(b);
Assert.IsNotNull(c);
Assert.IsTrue(Equals(a.GetHashCode(), b.GetHashCode()));
Assert.IsFalse(Equals(a.GetHashCode(), c.GetHashCode()));
}
/// <summary>
/// Visits a JSON expression tree array node.
/// </summary>
/// <param name="node">JSON expression tree array node to visit.</param>
/// <returns>Copy of the expression tree node.</returns>
public override Expression VisitArray(ArrayExpression node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
var elements = default(Expression[]);
var n = node.ElementCount;
for (var i = 0; i < n; i++)
{
var oldElement = node.GetElement(i);
var newElement = Visit(oldElement);
if (elements != null)
{
elements[i] = newElement;
}
else
{
if (oldElement != newElement)
{
elements = new Expression[n];
for (var j = 0; j < i; j++)
{
elements[j] = node.GetElement(j);
}
elements[i] = newElement;
}
}
}
if (elements != null)
{
return(Expression.Array(elements));
}
return(node);
}
public void ExpressionPropertyTests_ArrayExpressionString()
{
var data = new
{
test = new ArrFoo()
{
Strings = new List <string>()
{
"a", "b", "c"
}
}
};
var val = new ArrayExpression <string>("test.Strings");
Assert.IsNotNull(val.ExpressionText);
Assert.IsNull(val.Value);
var(result, error) = val.TryGetValue(data);
Assert.AreEqual(JsonConvert.SerializeObject(data.test.Strings, settings), JsonConvert.SerializeObject(result, settings: settings));
CollectionAssert.AreEqual(data.test.Strings, result);
val = new ArrayExpression <string>("=test.Strings");
Assert.IsNotNull(val.ExpressionText);
Assert.IsNull(val.Value);
(result, error) = val.TryGetValue(data);
Assert.AreEqual(JsonConvert.SerializeObject(data.test.Strings, settings), JsonConvert.SerializeObject(result, settings: settings));
CollectionAssert.AreEqual(data.test.Strings, result);
val = new ArrayExpression <string>(data.test.Strings);
Assert.IsNull(val.ExpressionText);
Assert.IsNotNull(val.Value);
(result, error) = val.TryGetValue(data);
Assert.AreEqual(JsonConvert.SerializeObject(data.test.Strings, settings), JsonConvert.SerializeObject(result, settings: settings));
CollectionAssert.AreEqual(data.test.Strings, result);
val = new ArrayExpression <string>(data.test.Strings);
Assert.IsNull(val.ExpressionText);
Assert.IsNotNull(val.Value);
(result, error) = val.TryGetValue(data);
Assert.AreEqual(JsonConvert.SerializeObject(data.test.Strings, settings), JsonConvert.SerializeObject(result, settings: settings));
CollectionAssert.AreEqual(data.test.Strings, result);
}
public void ExpressionPropertyTests_ArrayExpressionObject()
{
var data = new
{
test = new ArrFoo()
{
Objects = new List <Foo>()
{
new Foo()
{
Age = 13,
Name = "joe"
}
}
}
};
var val = new ArrayExpression <Foo>("test.Objects");
Assert.NotNull(val.ExpressionText);
Assert.Null(val.Value);
var(result, error) = val.TryGetValue(data);
Assert.Equal(data.test.Objects, result);
val = new ArrayExpression <Foo>("=test.Objects");
Assert.NotNull(val.ExpressionText);
Assert.Null(val.Value);
(result, error) = val.TryGetValue(data);
Assert.Equal(data.test.Objects, result);
val = new ArrayExpression <Foo>(data.test.Objects);
Assert.Null(val.ExpressionText);
Assert.NotNull(val.Value);
(result, error) = val.TryGetValue(data);
Assert.Equal(JsonConvert.SerializeObject(data.test.Objects, settings), JsonConvert.SerializeObject(result, settings));
val = new ArrayExpression <Foo>(JArray.FromObject(data.test.Objects));
Assert.Null(val.ExpressionText);
Assert.NotNull(val.Value);
(result, error) = val.TryGetValue(data);
Assert.Equal(JsonConvert.SerializeObject(data.test.Objects, settings), JsonConvert.SerializeObject(result, settings));
}
public JsValue EvaluateArrayExpression(ArrayExpression arrayExpression)
{
var a = _engine.Array.Construct(new JsValue[] { arrayExpression.Elements.Count() });
var n = 0;
var elements = arrayExpression.Elements;
for (int i = 0, len = elements.Count; i < len; i++)
{
var expr = elements[i];
if (expr != null)
{
var value = _engine.GetValue(EvaluateExpression(expr));
a.DefineOwnProperty(n.ToString(),
new PropertyDescriptor(value, true, true, true), false);
}
n++;
}
return(a);
}
public object VisitArrayExpression(ArrayExpression expr, object context)
{
StringBuilder.Append("[ ");
PushIndent();
int i = 0;
foreach (Expression element in expr.Elements)
{
if (i > 0)
{
StringBuilder.AppendLine(", ");
StringBuilder.Append(IndentationContents);
}
element.AcceptVisitor(this, context);
i++;
}
PopIndent();
StringBuilder.Append(" ]");
return(null);
}
public void ResolveNestedCollectionTest()
{
ArrayExpression root = new ArrayExpression();
ArrayExpression child1 = new ArrayExpression();
ArrayExpression child2 = new ArrayExpression();
root.Add(child1);
root.Add(child2);
ObjectExpression childA = new ObjectExpression();
child1.Add(childA);
ObjectExpression childB = new ObjectExpression();
child1.Add(childB);
Expression actual = ResolveReference(root, "$[0][1]");
Assert.AreSame(childB, actual, "$[0][1] did not resolve correctly");
}
public void TestReplaceVariablesArrayIndexString()
{
var variable = new VariableExpression("variable");
var index = new StringConstantExpression("str");
var value = new IntegerConstantExpression(99);
var array = new ArrayExpression();
array.Entries.Add(value);
var expr = new IndexedVariableExpression(variable, index);
var scope = new InterpreterScope();
scope.AssignVariable(variable, array);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.False);
Assert.That(result, Is.InstanceOf <ParseErrorExpression>());
Assert.That(((ParseErrorExpression)result).Message, Is.EqualTo("Index does not evaluate to an integer constant"));
}
public void Equals()
{
ArrayExpression expr1 = new ArrayExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) });
ArrayExpression expr2 = new ArrayExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2), new ConstantExpression(3) });
ArrayExpression expr3 = new ArrayExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(3) });
ArrayExpression expr4 = new ArrayExpression(new IExpression[] { });
ArrayExpression expr5 = new ArrayExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) });
Assert.IsTrue(expr1.Equals(expr5));
Assert.IsTrue(expr5.Equals(expr1));
Assert.AreEqual(expr1.GetHashCode(), expr5.GetHashCode());
Assert.IsFalse(expr1.Equals(null));
Assert.IsFalse(expr1.Equals(123));
Assert.IsFalse(expr1.Equals(expr2));
Assert.IsFalse(expr2.Equals(expr1));
Assert.IsFalse(expr1.Equals(expr3));
Assert.IsFalse(expr3.Equals(expr1));
Assert.IsFalse(expr1.Equals(expr4));
Assert.IsFalse(expr4.Equals(expr1));
}
public void TestGetModifications()
{
var variable1 = new VariableExpression("variable1");
var variable2 = new VariableExpression("variable2");
var value1 = new IntegerConstantExpression(98);
var value2 = new IntegerConstantExpression(99);
var value3 = new IntegerConstantExpression(1);
var expr = new ArrayExpression();
expr.Entries.Add(variable1);
expr.Entries.Add(value1);
expr.Entries.Add(variable2);
expr.Entries.Add(value2);
expr.Entries.Add(value3);
var modifications = new HashSet <string>();
((INestedExpressions)expr).GetModifications(modifications);
Assert.That(modifications.Count, Is.EqualTo(0));
}
/// <summary>
/// Constructs a builder used to build the deserialized collection
/// </summary>
/// <param name="collection">an existing collection object or null for a new collection</param>
/// <param name="list">the list expression</param>
/// <param name="itemType">the type of the items</param>
/// <returns>collection builder</returns>
protected virtual ICollectionBuilder ConstructBuilder(object collection, ArrayExpression list, out Type itemType)
{
Type listType = collection != null?collection.GetType() : list.ResultType;
ITypeData typeHandler = Settings.Types[listType];
CollectionHandler collHandler = typeHandler.CollectionHandler;
itemType = collHandler.GetItemType(listType);
if (itemType == null)
{
throw new Exception("Null item type returned from " + collHandler.GetType() + " for Collection type: " + listType);
}
if (collection != null)
{
return(collHandler.ConstructBuilder(collection));
}
else
{
return(collHandler.ConstructBuilder(listType, list.Items.Count));
}
}
public void TestReplaceVariablesArray()
{
var variable = new VariableExpression("variable");
var index = new IntegerConstantExpression(0);
var indexVariable = new VariableExpression("index");
var value = new IntegerConstantExpression(99);
var array = new ArrayExpression();
array.Entries.Add(value);
var expr = new IndexedVariableExpression(variable, indexVariable);
var scope = new InterpreterScope();
scope.AssignVariable(variable, array);
scope.AssignVariable(indexVariable, index);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.True);
Assert.That(result, Is.InstanceOf <IntegerConstantExpression>());
Assert.That(((IntegerConstantExpression)result).Value, Is.EqualTo(99));
}
private IExpression ParseTermExpression()
{
if (this.TryParse(TokenType.Name, "new"))
{
return(ParseNewExpression());
}
IExpression expression = this.ParseSimpleTermExpression();
while (this.TryParse(TokenType.Operator, ".") || this.TryParse(TokenType.Separator, "[", "("))
{
if (this.TryParse(TokenType.Operator, "."))
{
this.lexer.NextToken();
string name = this.ParseName();
IList <IExpression> arguments = null;
if (this.TryParse(TokenType.Separator, "("))
{
arguments = this.ParseArgumentList();
}
expression = new DotExpression(expression, name, arguments);
continue;
}
if (this.TryParse(TokenType.Separator, "("))
{
IList <IExpression> arguments = this.ParseArgumentList();
expression = new InvokeExpression(expression, arguments);
continue;
}
expression = new ArrayExpression(expression, this.ParseArrayArgumentList());
}
return(expression);
}
// 4.6
int IExpressionVisitor <int> .VisitArray(ArrayExpression expression)
{
if (expression.HasElement)
{
_Writer.WriteLine('[');
_Writer.Indent++;
for (var i = 0; i < expression.Elements.Count; i++)
{
expression.Elements[i].Accept(this);
if (i < expression.Elements.Count - 1)
{
_Writer.Write(',');
}
}
_Writer.Indent--;
_Writer.Write(']');
}
else
{
_Writer.Write("[]");
}
return(0);
}
/// <summary>
/// Serializes the data into a json array expression.
/// </summary>
/// <param name="data">the data to serialize</param>
/// <param name="currentPath">the current path to the data</param>
/// <param name="serializer">serializer instance to use to serialize list items</param>
/// <returns>a json array expression representation</returns>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
ITypeData handler = Settings.Types[data.GetType()];
CollectionHandler collectionHandler = handler.CollectionHandler;
Type elemType = collectionHandler.GetItemType(handler.ForType);
int index = 0;
ArrayExpression expression = new ArrayExpression();
foreach (object value in collectionHandler.GetEnumerable(data))
{
Expression itemExpr = serializer.Serialize(value, currentPath.Append(index));
if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), elemType))
{
itemExpr = new CastExpression(value.GetType(), itemExpr);
}
expression.Add(itemExpr);
index++;
}
return(expression);
}
public void TestGetDependencies()
{
var variable1 = new VariableExpression("variable1");
var variable2 = new VariableExpression("variable2");
var value1 = new IntegerConstantExpression(98);
var value2 = new IntegerConstantExpression(99);
var value3 = new IntegerConstantExpression(1);
var expr = new ArrayExpression();
expr.Entries.Add(variable1);
expr.Entries.Add(value1);
expr.Entries.Add(variable2);
expr.Entries.Add(value2);
expr.Entries.Add(value3);
var dependencies = new HashSet <string>();
((INestedExpressions)expr).GetDependencies(dependencies);
Assert.That(dependencies.Count, Is.EqualTo(2));
Assert.That(dependencies.Contains("variable1"));
Assert.That(dependencies.Contains("variable2"));
}
protected override ExpressionBody Transform(ArrayExpression ax)
{
var elements = new List <ExpressionBody>(ax.Elements.Length);
var i = 0;
for (; i < ax.Elements.Length; ++i)
{
var element = ax.Elements[i];
if (element is ItemElement item)
{
elements.Add(Transform(item.Value));
}
else
{
break;
}
}
var arr = LX.NewArrayInit(typeof(LogEventPropertyValue), elements.ToArray());
var collected = LX.Call(CollectSequenceElementsMethod, arr);
for (; i < ax.Elements.Length; ++i)
{
var element = ax.Elements[i];
if (element is ItemElement item)
{
collected = LX.Call(ExtendSequenceValueWithItemMethod, collected, Transform(item.Value));
}
else
{
var spread = (SpreadElement)element;
collected = LX.Call(ExtendSequenceValueWithSpreadMethod, collected, Transform(spread.Content));
}
}
return(LX.Call(ConstructSequenceValueMethod, collected));
}
public void TestNestedExpressions()
{
var variable1 = new VariableExpression("variable1");
var variable2 = new VariableExpression("variable2");
var value1 = new IntegerConstantExpression(98);
var value2 = new IntegerConstantExpression(99);
var value3 = new IntegerConstantExpression(1);
var expr = new ArrayExpression();
expr.Entries.Add(variable1);
expr.Entries.Add(value1);
expr.Entries.Add(variable2);
expr.Entries.Add(value2);
expr.Entries.Add(value3);
var nested = ((INestedExpressions)expr).NestedExpressions;
Assert.That(nested.Count(), Is.EqualTo(5));
Assert.That(nested.Contains(variable1));
Assert.That(nested.Contains(variable2));
Assert.That(nested.Contains(value1));
Assert.That(nested.Contains(value2));
Assert.That(nested.Contains(value3));
}
public void TestPopFunctionCall()
{
var scope = new InterpreterScope();
var array = new ArrayExpression();
array.Entries.Add(new FunctionCallExpression("happy", new ExpressionBase[] { new IntegerConstantExpression(1) }));
scope.DefineVariable(new VariableDefinitionExpression("arr"), array);
var happyFunc = new FunctionDefinitionExpression("happy");
happyFunc.Parameters.Add(new VariableDefinitionExpression("num1"));
happyFunc.Expressions.Add(new ReturnExpression(new VariableExpression("num1")));
scope.AddFunction(happyFunc);
var entry = Evaluate("array_pop(arr)", scope);
// function call should not be evaluated when it's popped off the array
Assert.That(entry, Is.InstanceOf <FunctionCallExpression>());
Assert.That(((FunctionCallExpression)entry).FunctionName.Name, Is.EqualTo("happy"));
Assert.That(((FunctionCallExpression)entry).Parameters.Count, Is.EqualTo(1));
Assert.That(array.Entries.Count, Is.EqualTo(0));
}
private IScriptObject EvaluateExpression(ArrayExpression expression)
{
var items = new List <IScriptObject>();
if (expression.Items != null)
{
foreach (var i in expression.Items)
{
items.Add(EvaluateExpression(i));
}
}
try
{
return(this.ObjectCreator.CreateArray(this, items));
}
catch (RuntimeException)
{
throw;
}
catch (Exception ex)
{
throw new RuntimeException(expression.LinePragma, ex.Message, ex);
}
}
protected abstract void Visit(ArrayExpression node);
public override object?Visit(ArrayExpression node)
{
AddNodeInfo();
VisitChildren(node.Elements.Cast <Node>().ToArray());
return(null);
}
public JintArrayExpression(ArrayExpression expression) : base(expression)
{
_initialized = false;
}
public override object Visit(ArrayExpression that, object value = null)
{
PrintPrologue(that);
PrintNodeId("Array", that.Array);
PrintNodeId("Index", that.Index);
PrintEpilogue(that);
that.Array.Visit(this);
that.Index.Visit(this);
return null;
}
public override object Visit(ArrayExpression that, object value)
{
Storage index = new TemporaryStorage(CreateTemporary());
_writer.Write(index.ToString() + " = ");
_writer.Write("getelementptr ");
that.Type.Visit(this);
_writer.Write("* ");
that.Array.Visit(this);
_writer.Write(", i32 ");
that.Index.Visit(this);
_writer.Write(", i32 0");
_writer.WriteLine();
return (object) index;
}
public ISet <DescriptorKind> Visit(ArrayExpression expression)
{
return(_emptySet);
}
public void CanCreateArrayExpressionWithParams()
{
var a = new ArrayExpression(1, 2, 3);
Assert.IsNotNull(a);
Assert.IsNotNull(a.Elements);
Assert.AreEqual(3, a.Elements.Count);
Assert.AreEqual("[1,2,3];", a.ToString());
}
LLVMValueRef IExpressionVisitor.Visit(ArrayExpression exp)
{
throw new NotImplementedException();
}
public override object Visit(ArrayExpression that, object value = null)
{
that.Array.Visit(this);
that.Index.Visit(this);
return null;
}
protected override void VisitArrayExpression(ArrayExpression arrayExpression)
{
using (StartNodeObject(arrayExpression))
Member("elements", arrayExpression.Elements);
}
void PrintExpression(ArrayExpression e, int d)
{
Say("ArrayExpression("); Say(e.Type.ToString()); SayLn(",");
PrintExpression(e.Size, d + 1); SayLn(",");
PrintExpression(e.Init, d + 1); Say(")");
}
/** Parses an expression. */
private Expression ParseExpression()
{
Expression result;
/** Parse the expression prefix. */
switch (_matcher.This.Kind)
{
#if DONE
case TokenKind.Keyword_Base:
result = (Expression) ParseParentReference();
break;
#endif
case TokenKind.Dot:
result = (Expression) ParseMemberReference();
break;
case TokenKind.Exclamation:
result = (Expression) ParseGlobalReference();
break;
#if DONE
case TokenKind.Keyword_False:
case TokenKind.Keyword_True:
result = (Expression) ParseBooleanLiteral();
break;
#endif
case TokenKind.Name:
result = (Expression) ParseSymbolReference();
break;
case TokenKind.Literal_Cardinal:
result = (Expression) ParseCardinalLiteral();
break;
#if DONE
case TokenKind.Literal_Character:
result = (Expression) ParseCharacterLiteral();
break;
#endif
case TokenKind.Literal_Text:
result = (Expression) ParseTextLiteral();
break;
#if DONE
case TokenKind.Keyword_New:
result = (Expression) ParseNewExpression();
break;
case TokenKind.Keyword_None:
result = (Expression) ParseNoneExpression();
break;
case TokenKind.Keyword_This:
{
_matcher.Match(TokenKind.Keyword_This);
result = (Expression) ParseMemberReference();
break;
}
case TokenKind.BracketBegin:
result = (Expression) ParseBracketExpression();
break;
#endif
default:
/** \todo The \c ToString() invokation does not call our \c ToString() - why? */
throw new ParserError(_matcher.This.Cursor, "Expression expected, found " + _matcher.This.Kind.ToString());
}
bool done = false;
while (!done)
{
switch (_matcher.This.Kind)
{
case TokenKind.Dot:
{
Token start = _matcher.Match(TokenKind.Dot);
Token label = _matcher.Match(TokenKind.Name);
result = new PrefixReference(start.Cursor, result, label.Text);
break;
}
#if DONE
case TokenKind.BracketBegin:
{
Token start = _matcher.Match(TokenKind.BracketBegin);
Expression other = ParseExpression();
_matcher.Match(TokenKind.BracketClose);
result = new ArrayExpression(start.Cursor, result, other);
break;
}
#endif
case TokenKind.ParenthesisBegin:
{
Token start = _matcher.This;
Expression[] arguments = ParseArguments();
result = new CallExpression(start.Cursor, result, arguments);
break;
}
default:
done = true;
break;
}
}
return result;
}
public override object Visit(ArrayExpression that, object value)
{
that.Array.Visit(this);
_writer.Write('[');
that.Index.Visit(this);
_writer.Write(']');
return null;
}
public void TestArrayExpression()
{
ArrayExpression node = new ArrayExpression(GetExpressionList(), DefaultLineInfo);
CheckSerializationRoundTrip(node);
}
public Expression Visit(ArrayExpression expression)
{
return(new ArrayExpression(expression.Name, expression.Accessors.Select(accessor => accessor.Accept(this)).ToArray()));
}
public JintArrayExpression(Engine engine, ArrayExpression expression) : base(engine, expression)
{
_initialized = false;
}
protected virtual void EmitArrayExpression(ArrayExpression expression, bool isStatement = false)
{
Append("[");
EmitTuple(expression.Elements);
Append("]");
}
public void CanSetExpressionsListOfArrayExpression()
{
var list = new List<Expression> { 1, 2, 3 };
var a = new ArrayExpression(list);
Assert.IsNotNull(a);
Assert.IsNotNull(a.Elements);
Assert.AreEqual(3, a.Elements.Count);
Assert.AreEqual("[1,2,3];", a.ToString());
}
public override bool Evaluate(InterpreterScope scope, out ExpressionBase result)
{
var start = GetIntegerParameter(scope, "start", out result);
if (start == null)
{
return(false);
}
var stop = GetIntegerParameter(scope, "stop", out result);
if (stop == null)
{
return(false);
}
var step = GetIntegerParameter(scope, "step", out result);
if (step == null)
{
return(false);
}
if (step.Value == 0)
{
result = new ParseErrorExpression("step must not be 0", step);
return(false);
}
var array = new ArrayExpression();
if (start.Value > stop.Value)
{
if (step.Value > 0)
{
result = new ParseErrorExpression("step must be negative if start is after stop", step.Location.Start.Line > 0 ? step : stop);
return(false);
}
for (int i = start.Value; i >= stop.Value; i += step.Value)
{
array.Entries.Add(new IntegerConstantExpression(i));
}
}
else
{
if (step.Value < 0)
{
result = new ParseErrorExpression("step must be positive if stop is after start", step);
return(false);
}
for (int i = start.Value; i <= stop.Value; i += step.Value)
{
array.Entries.Add(new IntegerConstantExpression(i));
}
}
result = array;
CopyLocation(result);
return(true);
}
public virtual object Visit(ArrayExpression that, object value)
{
throw new System.NotImplementedException();
}
