public override Ust VisitAssignmentExpression(AssignmentExpressionSyntax node)
{
var textSpan = node.GetTextSpan();
if (node.Left is TupleExpressionSyntax tupleLeft &&
node.Right is TupleExpressionSyntax tupleRight)
{
var assignments = new List <AssignmentExpression>();
for (int i = 0; i < tupleLeft.Arguments.Count; i++)
{
var leftNode = ((DeclarationExpressionSyntax)tupleLeft.Arguments[i].Expression)?.Designation;
assignments.Add(new AssignmentExpression
{
Left = (Expression)base.Visit(leftNode),
Right = (Expression)base.Visit(tupleRight.Arguments[i]),
TextSpan = textSpan
});
}
return(new VariableDeclarationExpression(null, assignments, textSpan));
}
var left = (Expression)base.Visit(node.Left);
var right = (Expression)base.Visit(node.Right);
return(UstUtils.CreateAssignExpr(left, right, textSpan,
node.OperatorToken.ValueText, node.OperatorToken.GetTextSpan()));
}
public override Ust VisitAssignmentExpression(AssignmentExpressionSyntax node)
{
var left = (Expression)base.Visit(node.Left);
var right = (Expression)base.Visit(node.Right);
return(UstUtils.CreateAssignExpr(left, right, node.GetTextSpan(),
node.OperatorToken.ValueText, node.OperatorToken.GetTextSpan()));
}
protected AssignmentExpression CreateAssignExpr(Expression left, Expression right, ParserRuleContext context, ParserRuleContext assignOperator)
{
return(UstUtils.CreateAssignExpr(left, right, context.GetTextSpan(), assignOperator?.GetText(), assignOperator?.GetTextSpan() ?? TextSpan.Zero));
}
public Ust VisitExpression(JavaParser.ExpressionContext context)
{
var textSpan = context.GetTextSpan();
var child0Terminal = context.GetChild(0) as ITerminalNode;
Expression target;
Expression result;
if (child0Terminal != null)
{
switch (child0Terminal.Symbol.Type)
{
case JavaParser.NEW:
result = (Expression)Visit(context.creator());
return(result);
case JavaParser.LPAREN: // '(' type ')' expression
var type = (TypeToken)Visit(context.typeType());
target = (Expression)Visit(context.expression(0));
result = new CastExpression(type, target, textSpan);
return(result);
default: // unary operator ('+', '-', '++', '--', '~', '!')
UnaryOperator op = UnaryOperatorLiteral.PrefixTextUnaryOperator[child0Terminal.GetText()];
var opLiteral = new UnaryOperatorLiteral(op, child0Terminal.GetTextSpan());
target = (Expression)Visit(context.expression(0));
result = new UnaryOperatorExpression(opLiteral, target, textSpan);
return(result);
}
}
ArgsUst args;
var child1Terminal = context.GetChild(1) as ITerminalNode;
if (child1Terminal != null)
{
switch (child1Terminal.Symbol.Type)
{
case JavaParser.DOT: // '.'
target = (Expression)Visit(context.expression(0));
if (context.methodCall() != null)
{
var invocation = (InvocationExpression)Visit(context.methodCall());
return(new InvocationExpression(
new MemberReferenceExpression(target, invocation.Target, target.TextSpan.Union(invocation.Target.TextSpan)),
invocation.Arguments,
textSpan));
}
// TODO: implement base processing
Expression rightPart = null;
if (context.IDENTIFIER() != null)
{
rightPart = (IdToken)Visit(context.IDENTIFIER());
}
else if (context.THIS() != null)
{
rightPart = new ThisReferenceToken(context.THIS().GetTextSpan());
}
if (rightPart != null)
{
return(new MemberReferenceExpression(target, rightPart, textSpan));
}
if (context.innerCreator() != null)
{
return(Visit(context.innerCreator()));
}
if (context.explicitGenericInvocation() != null)
{
return(VisitChildren(context.explicitGenericInvocation()).ToExpressionIfRequired());
}
break;
case JavaParser.LBRACK: // '['
target = (Expression)Visit(context.expression(0));
Expression expr = (Expression)Visit(context.expression(1));
args = new ArgsUst(new Expression[] { expr }, expr.TextSpan);
result = new IndexerExpression(target, args, textSpan);
return(result);
case JavaParser.INSTANCEOF: // x instanceof y -> (y)x != null
var expression = (Expression)Visit(context.expression(0));
var type = (TypeToken)Visit(context.typeType());
result = new BinaryOperatorExpression(context.GetTextSpan())
{
Left = new CastExpression(type, expression, context.GetTextSpan()),
Operator = new BinaryOperatorLiteral(BinaryOperator.NotEqual, default),
Right = new NullLiteral(default),
Root = root
};
return(result);
case JavaParser.QUESTION: // '?'
var condition = (Expression)Visit(context.expression(0));
var trueExpr = (Expression)Visit(context.expression(1));
var falseExpr = (Expression)Visit(context.expression(2));
result = new ConditionalExpression(condition, trueExpr, falseExpr, textSpan);
return(result);
case JavaParser.COLONCOLON:
return(VisitChildren(context));
default: // binary operator
var left = (Expression)Visit(context.expression(0));
JavaParser.ExpressionContext expr1 = context.expression(1);
if (expr1 != null)
{
string opText = string.Concat(context.children.Skip(1).Take(context.children.Count - 2));
var right = (Expression)Visit(expr1);
// TODO: fix via grammar refactoring (alternative labels).
if (opText == "=" ||
(opText.EndsWith("=") && BinaryOperatorLiteral.TextBinaryOperator.ContainsKey(opText.Remove(opText.Length - 1))))
{
result = UstUtils.CreateAssignExpr(left, right, context.GetTextSpan(),
opText, child1Terminal.GetTextSpan());
}
else
{
BinaryOperator op = BinaryOperatorLiteral.TextBinaryOperator[opText];
var opLiteral = new BinaryOperatorLiteral(op, child1Terminal.GetTextSpan());
result = new BinaryOperatorExpression(left, opLiteral, right, textSpan);
}
}
else
{
// post increment or decrement.
UnaryOperator op = UnaryOperatorLiteral.PostfixTextUnaryOperator[context.postfix.Text];
var opLiteral = new UnaryOperatorLiteral(op, child1Terminal.GetTextSpan());
result = new UnaryOperatorExpression(opLiteral, left, textSpan);
return(result);
}
return(result);
}
}
return(VisitChildren(context));
}
protected override MatchContext Match(Ust ust, MatchContext context)
{
var argsUst = ust as ArgsUst;
if (argsUst == null)
{
return(context.Fail());
}
List <Expression> args = argsUst.Collection;
MatchContext newContext = MatchContext.CreateWithInputParamsAndVars(context);
var matchedTextSpans = new List <TextSpan>();
int patternArgInd = 0;
int argInd = 0;
while (argInd < args.Count)
{
if (patternArgInd >= Args.Count)
{
break;
}
newContext = MatchContext.CreateWithInputParamsAndVars(newContext);
if (Args[patternArgInd] is PatternMultipleExpressions)
{
if (patternArgInd + 1 < Args.Count)
{
Expression arg = UstUtils.GetArgWithoutModifier(args[argInd]);
newContext = Args[patternArgInd + 1].MatchUst(arg, newContext);
matchedTextSpans.AddRange(newContext.Locations);
if (newContext.Success)
{
patternArgInd += 2;
}
}
else
{
matchedTextSpans.AddRange(newContext.Locations);
}
argInd += 1;
}
else
{
Expression arg = UstUtils.GetArgWithoutModifier(args[argInd]);
newContext = Args[patternArgInd].MatchUst(arg, newContext);
if (!newContext.Success)
{
break;
}
matchedTextSpans.AddRange(newContext.Locations);
patternArgInd += 1;
argInd += 1;
}
}
if (patternArgInd < Args.Count && Args[patternArgInd] is PatternMultipleExpressions)
{
patternArgInd += 1;
}
newContext = argInd != args.Count || patternArgInd != Args.Count
? context.Fail()
: context.AddMatches(matchedTextSpans);
return(newContext.AddUstIfSuccess(argsUst));
}
