public virtual void Visit(JsConditionalExpression node)
{
DefaultVisit(node);
node.Condition.Accept(this);
node.IfTrue.Accept(this);
node.IfFalse.Accept(this);
}
public virtual JsExpression VisitConditionalExpression(JsConditionalExpression expression, TData data)
{
var test = VisitExpression(expression.Test, data);
var truePart = VisitExpression(expression.TruePart, data);
var falsePart = VisitExpression(expression.FalsePart, data);
return(ReferenceEquals(test, expression.Test) && ReferenceEquals(truePart, expression.TruePart) && ReferenceEquals(falsePart, expression.FalsePart) ? expression : JsExpression.Conditional(test, truePart, falsePart));
}
public override void VisitConditionalExpression(JsConditionalExpression node)
{
node.Condition.Accept(this);
output.Append(" ? ");
node.IfTrue.Accept(this);
output.Append(" : ");
node.IfFalse.Accept(this);
}
public override void VisitConditionalExpression(JsConditionalExpression conditionalExpression)
{
if (conditionalExpression.TrueExpression.HasAnnotation <MayBeNullAnnotation>() || conditionalExpression.FalseExpression.HasAnnotation <MayBeNullAnnotation>())
{
conditionalExpression.AddAnnotation(MayBeNullAnnotation.Instance);
}
base.VisitConditionalExpression(conditionalExpression);
}
public virtual JsNode Visit(JsConditionalExpression node)
{
return(DefaultVisit(node, x =>
{
x.Condition = (JsExpression)x.Condition.Accept(this);
x.IfTrue = (JsExpression)x.IfTrue.Accept(this);
x.IfFalse = (JsExpression)x.IfFalse.Accept(this);
return x;
}));
}
private JsNode Trinary(OperatorResolveResult res)
{
if (res.OperatorType == ExpressionType.Conditional)
{
var node5 = new JsConditionalExpression {
Condition = VisitExpression(res.Operands[0]), TrueExpression = VisitExpression(res.Operands[1]), FalseExpression = VisitExpression(res.Operands[2])
};
return(node5);
}
else
{
throw new NotImplementedException();
}
}
/// <summary>
/// Parses the js conditional expression.
/// </summary>
/// <param name="literal">The literal.</param>
/// <param name="test">The test.</param>
/// <param name="expression">The expression.</param>
/// <returns>ReadOnlySpan<System.Char>.</returns>
/// <exception cref="ServiceStack.Script.SyntaxErrorException">Expected Conditional ':' but was {literal.DebugFirstChar()}</exception>
private static ReadOnlySpan <char> ParseJsConditionalExpression(this ReadOnlySpan <char> literal, JsToken test, out JsConditionalExpression expression)
{
literal = literal.Advance(1);
literal = literal.ParseJsExpression(out var consequent);
literal = literal.AdvancePastWhitespace();
if (!literal.FirstCharEquals(':'))
{
throw new SyntaxErrorException($"Expected Conditional ':' but was {literal.DebugFirstChar()}");
}
literal = literal.Advance(1);
literal = literal.ParseJsExpression(out var alternate);
expression = new JsConditionalExpression(test, consequent, alternate);
return(literal);
}
public object VisitConditionalExpression(JsConditionalExpression expression, bool parenthesized)
{
// Always parenthesize conditionals (but beware of double parentheses). Better this than accidentally getting the tricky precedence wrong sometimes.
if (!parenthesized)
{
_cb.Append("(");
}
// Also, be rather liberal when parenthesizing the operands, partly to avoid bugs, partly for readability.
VisitExpression(expression.Test, GetPrecedence(expression.Test.NodeType) >= PrecedenceMultiply);
_cb.Append(_space + "?" + _space);
VisitExpression(expression.TruePart, GetPrecedence(expression.TruePart.NodeType) >= PrecedenceMultiply);
_cb.Append(_space + ":" + _space);
VisitExpression(expression.FalsePart, GetPrecedence(expression.FalsePart.NodeType) >= PrecedenceMultiply);
if (!parenthesized)
{
_cb.Append(")");
}
return(null);
}
public void VisitConditionalExpression(JsConditionalExpression conditionalExpression)
{
VisitChildren(conditionalExpression);
}
public void Visit(JsConditionalExpression node)
{
BeforeVisit(node);
DefaultVisit(node, VisitConditionalExpression);
AfterVisit(node);
}
public virtual void VisitConditionalExpression(JsConditionalExpression node)
{
}
/// <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(JsConditionalExpression other)
{
return(Equals(Test, other.Test) &&
Equals(Consequent, other.Consequent) &&
Equals(Alternate, other.Alternate));
}
