CatchBlockSyntax ConvertCatchClause(int index, CSS.CatchClauseSyntax catchClause)
{
var statements = ConvertBlock(catchClause.Block);
if (catchClause.Declaration == null)
{
return(SyntaxFactory.CatchBlock(SyntaxFactory.CatchStatement(), statements));
}
var type = (TypeSyntax)catchClause.Declaration.Type.Accept(_nodesVisitor);
string simpleTypeName;
if (type is QualifiedNameSyntax)
{
simpleTypeName = ((QualifiedNameSyntax)type).Right.ToString();
}
else
{
simpleTypeName = type.ToString();
}
return(SyntaxFactory.CatchBlock(
SyntaxFactory.CatchStatement(
SyntaxFactory.IdentifierName(SyntaxTokenExtensions.IsKind(catchClause.Declaration.Identifier, CS.SyntaxKind.None) ? SyntaxFactory.Identifier($"__unused{simpleTypeName}{index + 1}__") : CommonConversions.ConvertIdentifier(catchClause.Declaration.Identifier)),
SyntaxFactory.SimpleAsClause(type),
catchClause.Filter == null ? null : SyntaxFactory.CatchFilterClause((ExpressionSyntax)catchClause.Filter.FilterExpression.Accept(_nodesVisitor))
), statements
));
}
public override SyntaxList <StatementSyntax> VisitLabeledStatement(CSS.LabeledStatementSyntax node)
{
return(SyntaxFactory.SingletonList <StatementSyntax>(SyntaxFactory.LabelStatement(CommonConversions.ConvertIdentifier(node.Identifier)))
.AddRange(ConvertBlock(node.Statement)));
}
bool ConvertForToSimpleForNext(CSS.ForStatementSyntax node, out StatementSyntax block)
{
// ForStatement -> ForNextStatement when for-loop is simple
// only the following forms of the for-statement are allowed:
// for (TypeReference name = start; name < oneAfterEnd; name += step)
// for (name = start; name < oneAfterEnd; name += step)
// for (TypeReference name = start; name <= end; name += step)
// for (name = start; name <= end; name += step)
// for (TypeReference name = start; name > oneAfterEnd; name -= step)
// for (name = start; name > oneAfterEnd; name -= step)
// for (TypeReference name = start; name >= end; name -= step)
// for (name = start; name >= end; name -= step)
block = null;
// check if the form is valid and collect TypeReference, name, start, end and step
bool hasVariable = node.Declaration != null && node.Declaration.Variables.Count == 1;
if (!hasVariable && node.Initializers.Count != 1)
{
return(false);
}
if (node.Incrementors.Count != 1)
{
return(false);
}
var iterator = node.Incrementors.FirstOrDefault()?.Accept(_nodesVisitor) as AssignmentStatementSyntax;
if (iterator == null || !iterator.IsKind(SyntaxKind.AddAssignmentStatement, SyntaxKind.SubtractAssignmentStatement))
{
return(false);
}
var iteratorIdentifier = iterator.Left as IdentifierNameSyntax;
if (iteratorIdentifier == null)
{
return(false);
}
var stepExpression = iterator.Right as LiteralExpressionSyntax;
if (stepExpression == null || !(stepExpression.Token.Value is int))
{
return(false);
}
int step = (int)stepExpression.Token.Value;
if (SyntaxTokenExtensions.IsKind(iterator.OperatorToken, SyntaxKind.MinusToken))
{
step = -step;
}
var condition = node.Condition as CSS.BinaryExpressionSyntax;
if (condition == null || !(condition.Left is CSS.IdentifierNameSyntax))
{
return(false);
}
if (((CSS.IdentifierNameSyntax)condition.Left).Identifier.IsEquivalentTo(iteratorIdentifier.Identifier))
{
return(false);
}
ExpressionSyntax end;
if (iterator.IsKind(SyntaxKind.SubtractAssignmentStatement))
{
if (condition.IsKind(CS.SyntaxKind.GreaterThanOrEqualExpression))
{
end = (ExpressionSyntax)condition.Right.Accept(_nodesVisitor);
}
else if (condition.IsKind(CS.SyntaxKind.GreaterThanExpression))
{
end = SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, (ExpressionSyntax)condition.Right.Accept(_nodesVisitor), SyntaxFactory.Token(SyntaxKind.PlusToken), CommonConversions.Literal(1));
}
else
{
return(false);
}
}
else
{
if (condition.IsKind(CS.SyntaxKind.LessThanOrEqualExpression))
{
end = (ExpressionSyntax)condition.Right.Accept(_nodesVisitor);
}
else if (condition.IsKind(CS.SyntaxKind.LessThanExpression))
{
end = SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, (ExpressionSyntax)condition.Right.Accept(_nodesVisitor), SyntaxFactory.Token(SyntaxKind.MinusToken), CommonConversions.Literal(1));
}
else
{
return(false);
}
}
VisualBasicSyntaxNode variable;
ExpressionSyntax start;
if (hasVariable)
{
var v = node.Declaration.Variables[0];
start = (ExpressionSyntax)v.Initializer?.Value.Accept(_nodesVisitor);
if (start == null)
{
return(false);
}
variable = SyntaxFactory.VariableDeclarator(
SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(CommonConversions.ConvertIdentifier(v.Identifier))),
node.Declaration.Type.IsVar ? null : SyntaxFactory.SimpleAsClause((TypeSyntax)node.Declaration.Type.Accept(_nodesVisitor)),
null
);
}
else
{
var initializer = node.Initializers.FirstOrDefault() as CSS.AssignmentExpressionSyntax;
if (initializer == null || !initializer.IsKind(CS.SyntaxKind.SimpleAssignmentExpression))
{
return(false);
}
if (!(initializer.Left is CSS.IdentifierNameSyntax))
{
return(false);
}
if (((CSS.IdentifierNameSyntax)initializer.Left).Identifier.IsEquivalentTo(iteratorIdentifier.Identifier))
{
return(false);
}
variable = initializer.Left.Accept(_nodesVisitor);
start = (ExpressionSyntax)initializer.Right.Accept(_nodesVisitor);
}
block = SyntaxFactory.ForBlock(
SyntaxFactory.ForStatement(variable, start, end, step == 1 ? null : SyntaxFactory.ForStepClause(CommonConversions.Literal(step))),
ConvertBlock(node.Statement),
SyntaxFactory.NextStatement()
);
return(true);
}
public override SyntaxList <StatementSyntax> VisitForEachStatement(CSS.ForEachStatementSyntax node)
{
VisualBasicSyntaxNode variable;
if (node.Type.IsVar)
{
variable = SyntaxFactory.IdentifierName(CommonConversions.ConvertIdentifier(node.Identifier));
}
else
{
variable = SyntaxFactory.VariableDeclarator(
SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(CommonConversions.ConvertIdentifier(node.Identifier))),
SyntaxFactory.SimpleAsClause((TypeSyntax)node.Type.Accept(_nodesVisitor)),
null
);
}
var expression = (ExpressionSyntax)node.Expression.Accept(_nodesVisitor);
var stmt = ConvertBlock(node.Statement);
var block = SyntaxFactory.ForEachBlock(
SyntaxFactory.ForEachStatement(variable, expression),
stmt,
SyntaxFactory.NextStatement()
);
return(SyntaxFactory.SingletonList <StatementSyntax>(block));
}