public override SyntaxList <StatementSyntax> VisitForStatement(CSS.ForStatementSyntax node)
{
StatementSyntax block;
if (!ConvertForToSimpleForNext(node, out block))
{
var stmts = ConvertBlock(node.Statement)
.AddRange(node.Incrementors.Select(ConvertSingleExpression));
var condition = node.Condition == null?CommonConversions.Literal(true) : (ExpressionSyntax)node.Condition.Accept(_nodesVisitor);
block = SyntaxFactory.WhileBlock(
SyntaxFactory.WhileStatement(condition),
stmts
);
var declarations = new List <StatementSyntax>();
if (node.Declaration != null)
{
var syntaxTokenList = SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.DimKeyword));
declarations.Add(SyntaxFactory.LocalDeclarationStatement(syntaxTokenList, _commonConversions.RemodelVariableDeclaration(node.Declaration)));
}
return(SyntaxFactory.List(declarations.Concat(node.Initializers.Select(ConvertSingleExpression))).Add(block));
}
return(SyntaxFactory.SingletonList(block));
}
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));
}
public MethodBodyExecutableStatementVisitor(SemanticModel semanticModel,
CommentConvertingVisitorWrapper <VisualBasicSyntaxNode> nodesVisitor, CommonConversions commonConversions)
{
this._semanticModel = semanticModel;
this._nodesVisitor = nodesVisitor;
_commonConversions = commonConversions;
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(this);
}
public MethodBodyVisitor(SemanticModel semanticModel,
CSharpSyntaxVisitor <VisualBasicSyntaxNode> nodesVisitor, TriviaConverter triviaConverter,
CommonConversions commonConversions)
{
this._semanticModel = semanticModel;
this._nodesVisitor = nodesVisitor;
_commonConversions = commonConversions;
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(this, triviaConverter);
}
public override SyntaxList <StatementSyntax> VisitLocalDeclarationStatement(CSS.LocalDeclarationStatementSyntax node)
{
var modifiers = CommonConversions.ConvertModifiers(node.Modifiers, TokenContext.Local);
if (modifiers.Count == 0)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.DimKeyword));
}
return(SyntaxFactory.SingletonList <StatementSyntax>(
SyntaxFactory.LocalDeclarationStatement(
modifiers, _commonConversions.RemodelVariableDeclaration(node.Declaration)
)
));
}
public override SyntaxList <StatementSyntax> VisitForEachVariableStatement(CSS.ForEachVariableStatementSyntax node)
{
var loopVar = node.Variable.Accept(_nodesVisitor);
var extraStatements = new List <StatementSyntax>();
if (node.Variable is CSS.DeclarationExpressionSyntax des && des.Designation is CSS.ParenthesizedVariableDesignationSyntax pv)
{
var tupleName = CommonConversions.GetTupleName(pv);
extraStatements.AddRange(pv.Variables.Select((v, i) => {
var initializer = SyntaxFactory.EqualsValue(SyntaxFactory.SimpleMemberAccessExpression(
SyntaxFactory.IdentifierName(tupleName),
SyntaxFactory.IdentifierName("Item" + (i + 1).ToString())));
VariableDeclaratorSyntax variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(
SyntaxFactory.ModifiedIdentifier(SyntaxFactory.Identifier(v.ToString())))
.WithInitializer(initializer);
return(CommonConversions.CreateLocalDeclarationStatement(variableDeclaratorSyntax));
}));
}
return(CreateForEachStatement(loopVar, node.Expression, node.Statement, extraStatements.ToArray()));
}
public override SyntaxList <StatementSyntax> VisitGotoStatement(CSS.GotoStatementSyntax node)
{
LabelSyntax label;
if (node.IsKind(CS.SyntaxKind.GotoCaseStatement, CS.SyntaxKind.GotoDefaultStatement))
{
if (_blockInfo.Count == 0)
{
throw new InvalidOperationException("goto case/goto default outside switch is illegal!");
}
var labelExpression = node.Expression?.Accept(_nodesVisitor) ?? SyntaxFactory.ElseCaseClause();
_blockInfo.Peek().GotoCaseExpressions.Add(labelExpression);
label = SyntaxFactory.Label(SyntaxKind.IdentifierLabel, MakeGotoSwitchLabel(labelExpression));
}
else
{
label = SyntaxFactory.Label(SyntaxKind.IdentifierLabel, CommonConversions.ConvertIdentifier(((CSS.IdentifierNameSyntax)node.Expression).Identifier));
}
return(SyntaxFactory.SingletonList <StatementSyntax>(SyntaxFactory.GoToStatement(label)));
}
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
);
}
return(CreateForEachStatement(variable, node.Expression, 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.MinusEqualsToken))
{
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> VisitLabeledStatement(CSS.LabeledStatementSyntax node)
{
return(SyntaxFactory.SingletonList <StatementSyntax>(SyntaxFactory.LabelStatement(CommonConversions.ConvertIdentifier(node.Identifier)))
.AddRange(ConvertBlock(node.Statement)));
}
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
));
}