public void JsFormatter_AssignmentExpression()
{
var expr = new JsBinaryExpression(new JsAssignmentExpression(new JsIdentifierExpression("a"), new JsIdentifierExpression("c")), BinaryOperatorType.Equal, new JsIdentifierExpression("b"));
Assert.AreEqual("(a=c)==b", expr.FormatScript());
Assert.AreEqual("(a = c) == b", expr.FormatScript(niceMode: true));
}
public virtual JsExpression VisitBinaryExpression(JsBinaryExpression expression, TData data)
{
var left = VisitExpression(expression.Left, data);
var right = VisitExpression(expression.Right, data);
return(ReferenceEquals(left, expression.Left) && ReferenceEquals(right, expression.Right) ? expression : JsExpression.Binary(expression.NodeType, left, right));
}
public object VisitBinaryExpression(JsBinaryExpression expression, bool parenthesized)
{
int expressionPrecedence = GetPrecedence(expression.NodeType);
if (expression.NodeType == ExpressionNodeType.Index)
{
VisitExpression(expression.Left, GetPrecedence(expression.Left.NodeType) > expressionPrecedence);
_cb.Append("[");
VisitExpression(expression.Right, false);
_cb.Append("]");
}
else
{
bool isRightAssociative = expression.NodeType >= ExpressionNodeType.AssignFirst && expression.NodeType <= ExpressionNodeType.AssignLast;
string spaceBefore = expression.NodeType == ExpressionNodeType.InstanceOf || expression.NodeType == ExpressionNodeType.In ? " " : _space;
// If minifying, we need to beware of a + +b and a - -b.
string spaceAfter = (expression.NodeType == ExpressionNodeType.Add && expression.Right.NodeType == ExpressionNodeType.Positive) || (expression.NodeType == ExpressionNodeType.Subtract && expression.Right.NodeType == ExpressionNodeType.Negate) ? " " : spaceBefore;
VisitExpression(expression.Left, GetPrecedence(expression.Left.NodeType) > expressionPrecedence - (isRightAssociative ? 1 : 0));
_cb.Append(spaceBefore)
.Append(GetBinaryOperatorString(expression.NodeType))
.Append(spaceAfter);
VisitExpression(expression.Right, GetPrecedence(expression.Right.NodeType) > expressionPrecedence - (isRightAssociative ? 0 : 1));
}
return(null);
}
public override void VisitBinaryExpression(JsBinaryExpression node)
{
node.Left.Accept(this);
output.Append(" ");
output.Append(node.Operator.GetToken());
output.Append(" ");
node.Right.Accept(this);
}
public virtual JsNode Visit(JsBinaryExpression node)
{
return(DefaultVisit(node, x =>
{
x.Left = (JsExpression)x.Left.Accept(this);
x.Right = (JsExpression)x.Right.Accept(this);
return x;
}));
}
public void JsFormatter_KeywordUnaryExpression()
{
var expr = new JsBinaryExpression(
new JsIdentifierExpression("a").Unary(UnaryOperatorType.TypeOf),
BinaryOperatorType.Plus,
new JsLiteral(0).Unary(UnaryOperatorType.Void).Unary(UnaryOperatorType.Minus));
Assert.AreEqual("typeof a+-void 0", expr.FormatScript());
Assert.AreEqual("typeof a + -void 0", expr.FormatScript(niceMode: true));
}
public void JsFormatter_LessThanOperator()
{
var expr = new JsBinaryExpression(
new JsIdentifierExpression("a"),
BinaryOperatorType.LessOrEqual,
new JsIdentifierExpression("b"));
Assert.AreEqual("a<=b", expr.FormatScript());
Assert.AreEqual("a <= b", expr.FormatScript(niceMode: true));
}
public void JsTree_FrozenBlocksMutations()
{
var tree = new JsBinaryExpression(new JsIdentifierExpression("a").Member("b"), BinaryOperatorType.Plus, new JsLiteral(5));
var left = tree.Left.CastTo <JsMemberAccessExpression>();
left.MemberName = "lol";
tree.Freeze();
Assert.ThrowsException <InvalidOperationException>(() => left.MemberName = "omg");
Assert.AreEqual(left.MemberName, "lol");
Assert.ThrowsException <InvalidOperationException>(() => tree.Right.CastTo <JsLiteral>().Value = 8);
}
public void JsFormatter_UnaryExpression()
{
var expr = new JsBinaryExpression(
new JsIdentifierExpression("a").Unary(UnaryOperatorType.Increment, isPrefix: false),
BinaryOperatorType.Plus,
new JsIdentifierExpression("a").Unary(UnaryOperatorType.Increment, isPrefix: true))
.Unary(UnaryOperatorType.LogicalNot);
Assert.AreEqual("!(a++ + ++a)", expr.FormatScript());
Assert.AreEqual("!(a++ + ++a)", expr.FormatScript(niceMode: true));
}
public override JsExpression VisitBinaryExpression(JsBinaryExpression expression, object data)
{
if (expression.NodeType >= ExpressionNodeType.AssignFirst && expression.NodeType <= ExpressionNodeType.AssignLast)
{
_result = true;
return(expression);
}
else
{
return(base.VisitBinaryExpression(expression, data));
}
}
public override JsExpression VisitBinaryExpression(JsBinaryExpression expression, object data)
{
if (expression.NodeType >= ExpressionNodeType.AssignFirst && expression.NodeType <= ExpressionNodeType.AssignLast)
{
if (expression.Left is JsIdentifierExpression)
{
string name = ((JsIdentifierExpression)expression.Left).Name;
if (expression.NodeType != ExpressionNodeType.Assign)
{
Result.LocalReadSet.Add(name); // Compound assignment means that we both read and write the state.
}
Result.LocalWriteSet.Add(name);
base.VisitExpression(expression.Right, data);
return(expression);
}
else
{
Result.UsesExternalState = true; // Assigning to something that is not a local. This counts as external state.
}
}
return(base.VisitBinaryExpression(expression, data));
}
public void VisitBinaryExpression(JsBinaryExpression binaryExpression)
{
VisitChildren(binaryExpression);
switch (binaryExpression.Operator)
{
case BinaryOperatorType.Minus:
case BinaryOperatorType.Times:
case BinaryOperatorType.Divide:
case BinaryOperatorType.Modulo:
case BinaryOperatorType.Plus:
case BinaryOperatorType.BitwiseAnd:
case BinaryOperatorType.BitwiseOr:
case BinaryOperatorType.BitwiseXOr:
case BinaryOperatorType.LeftShift:
case BinaryOperatorType.RightShift:
case BinaryOperatorType.UnsignedRightShift:
SetType(binaryExpression, JsTypeInfo.Number);
break;
case BinaryOperatorType.Equal:
case BinaryOperatorType.NotEqual:
case BinaryOperatorType.Greater:
case BinaryOperatorType.GreaterOrEqual:
case BinaryOperatorType.Less:
case BinaryOperatorType.LessOrEqual:
case BinaryOperatorType.StrictlyEqual:
case BinaryOperatorType.StricltyNotEqual:
case BinaryOperatorType.InstanceOf:
case BinaryOperatorType.In:
SetType(binaryExpression, JsTypeInfo.Boolean);
break;
case BinaryOperatorType.ConditionalAnd:
case BinaryOperatorType.ConditionalOr:
SetType(binaryExpression, binaryExpression.Right.ResultType());
break;
default: throw new NotSupportedException();
}
}
public virtual void VisitBinaryExpression(JsBinaryExpression node)
{
}
public virtual void Visit(JsBinaryExpression node)
{
DefaultVisit(node);
node.Left.Accept(this);
node.Right.Accept(this);
}
/// <summary> /// Equalses the specified other. /// </summary> /// <param name="other">The other.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> protected bool Equals(JsBinaryExpression other) => Equals(Operator, other.Operator) && Equals(Left, other.Left) && Equals(Right, other.Right);
public void Visit(JsBinaryExpression node)
{
BeforeVisit(node);
DefaultVisit(node, VisitBinaryExpression);
AfterVisit(node);
}
private JsNode Binary(OperatorResolveResult res)
{
if (res.UserDefinedOperatorMethod != null && !Sk.UseNativeOperatorOverloads(res.UserDefinedOperatorMethod.DeclaringTypeDefinition))
{
var op2 = res.OperatorType.ExtractCompoundAssignment();
if (op2 != null)
{
var fakeRight = new OperatorResolveResult(res.Type, op2.Value, res.UserDefinedOperatorMethod, res.IsLiftedOperator, res.Operands);
var fakeAssign = Cs.Assign(res.Operands[0], fakeRight);
return(Visit(fakeAssign));
}
var fake = Cs.InvokeMethod(res.UserDefinedOperatorMethod, null, res.Operands[0], res.Operands[1]);
return(Visit(fake));
}
if (res.OperatorType == ExpressionType.Coalesce)
{
var fake = Cs.Conditional(res.Operands[0].NotEqual(Cs.Null(), Project), res.Operands[0], res.Operands[1], res.Type);
var fake2 = Visit(fake);
fake2 = new JsParenthesizedExpression {
Expression = (JsExpression)fake2
};
return(fake2);
}
var mrr = res.Operands[0] as MemberResolveResult;
if (mrr != null && mrr.Member.SymbolKind == SymbolKind.Event)
{
var pe = (IEvent)mrr.Member;
if (res.OperatorType.IsAny(ExpressionType.AddAssign, ExpressionType.SubtractAssign))
{
var accessor = res.OperatorType == ExpressionType.AddAssign ? pe.AddAccessor : pe.RemoveAccessor;
var fake = new CSharpInvocationResolveResult(mrr.TargetResult, accessor, new List <ResolveResult>
{
res.Operands[1]
});
var node6 = Visit(fake);
return(node6);
}
}
if (mrr != null && IsEntityFunctionProperty(mrr.Member, res))
{
var simpleOp = res.OperatorType.ExtractCompoundAssignment();
var pe = (IProperty)mrr.Member;
if (simpleOp != null)
{
// x.Name += "Hello" -> x.Name = x.Name + "Hello"
// x.Dic["Hello"] += 7 -> x.Dic["Hello"] = x.Dic["Hello"] + 7;
var fake = res.Operands[0].Assign(res.Operands[0].Binary(simpleOp.Value, res.Operands[1], res.Type));
var node6 = Visit(fake);
return(node6);
}
else if (res.OperatorType == ExpressionType.Assign)
{
var args = new List <ResolveResult>();
if (pe.IsIndexer)
{
var irrOp0 = (CSharpInvocationResolveResult)res.Operands[0];
args.AddRange(irrOp0.Arguments);
}
args.Add(res.Operands[1]);
var fake = new CSharpInvocationResolveResult(mrr.TargetResult, pe.Setter, args).AssociateWithOriginal(res);
var node6 = Visit(fake);
node6 = WrapSetterToReturnValueIfNeeded(res, node6);
return(node6);
}
}
if (res.Operands[0] is ConversionResolveResult && res.Operands[1] is ConstantResolveResult)
{
var leftConv = (ConversionResolveResult)res.Operands[0];
var rightConst = (ConstantResolveResult)res.Operands[1];
if (leftConv.Conversion.IsNumericConversion && leftConv.Input.Type == Cs.CharType(Project))
{
var value = ((char)(int)rightConst.ConstantValue).ToString();
var fake = Cs.Binary(leftConv.Input, res.OperatorType, Cs.Value(value, Project), leftConv.Input.Type);
return(Visit(fake));
}
}
if (res.Operands[0].Type.Kind == TypeKind.Delegate && res.Operands[1].Type.Kind == TypeKind.Delegate)
{
if (res.OperatorType.IsAny(ExpressionType.AddAssign, ExpressionType.SubtractAssign))
{
var op = res.OperatorType == ExpressionType.AddAssign ? ExpressionType.Add : ExpressionType.Subtract;
var fake = Cs.Assign(res.Operands[0], Cs.Binary(res.Operands[0], op, res.Operands[1], res.Type));
var node6 = Visit(fake);
return(node6);
}
else if (res.OperatorType.IsAny(ExpressionType.Add, ExpressionType.Subtract))
{
var combineMethod = Project.Compilation.FindType(KnownTypeCode.Delegate).GetMethods(t => t.Name == "Combine").FirstOrDefault();
var removeMethod = Project.Compilation.FindType(KnownTypeCode.Delegate).GetMethods(t => t.Name == "Remove").FirstOrDefault();
var meOp = res.OperatorType == ExpressionType.Add ? combineMethod : removeMethod;
var fake = Cs.Member(null, meOp).Invoke(res.Operands[0], res.Operands[1]);
var node6 = Visit(fake);
return(node6);
}
}
var node5 = new JsBinaryExpression {
Operator = Visit(res.OperatorType), Left = VisitExpression(res.Operands[0]), Right = VisitExpression(res.Operands[1])
};
if (res.OperatorType == ExpressionType.Equal && node5.Operator == "==")
{
var att = Compiler.GetJsExportAttribute();
if (att != null && att.UseExactEquals)
{
node5.Operator = "===";
}
}
if (res.OperatorType == ExpressionType.NotEqual && node5.Operator == "!=")
{
var att = Compiler.GetJsExportAttribute();
if (att != null && att.UseExactEquals)
{
node5.Operator = "!==";
}
}
return(node5);
}
public override JsExpression VisitBinaryExpression(JsBinaryExpression expression, object data)
{
_result = true;
return(expression);
}
