public override SyntaxList <StatementSyntax> VisitReturnStatement(CSS.ReturnStatementSyntax node)
{
StatementSyntax stmt;
if (node.Expression == null)
{
stmt = SyntaxFactory.ReturnStatement();
}
else
{
stmt = SyntaxFactory.ReturnStatement((ExpressionSyntax)node.Expression.Accept(nodesVisitor));
}
return(SyntaxFactory.SingletonList(stmt));
}
private VariableDeclaratorSyntax ConvertToVariableDeclarator(IsPatternExpressionSyntax node)
{
return(node.Pattern.TypeSwitch(
(DeclarationPatternSyntax d) => {
var id = ((IdentifierNameSyntax)d.Designation.Accept(_nodesVisitor)).Identifier;
var ids = SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(id));
TypeSyntax right = (TypeSyntax)d.Type.Accept(_nodesVisitor);
var simpleAsClauseSyntax = SyntaxFactory.SimpleAsClause(right);
var equalsValueSyntax = SyntaxFactory.EqualsValue(SyntaxFactory.LiteralExpression(SyntaxKind.NothingLiteralExpression, SyntaxFactory.Token(SyntaxKind.NothingKeyword)));
return SyntaxFactory.VariableDeclarator(ids, simpleAsClauseSyntax, equalsValueSyntax);
},
p => throw new ArgumentOutOfRangeException(nameof(p), p, null)));
}
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)
)
));
}
private static SyntaxToken CSharpDefaultVisibility(SyntaxKindExtensions.TokenContext context)
{
switch (context)
{
case SyntaxKindExtensions.TokenContext.Global:
return(SyntaxFactory.Token(SyntaxKind.FriendKeyword));
case SyntaxKindExtensions.TokenContext.Local:
case SyntaxKindExtensions.TokenContext.VariableOrConst:
case SyntaxKindExtensions.TokenContext.Member:
return(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
}
throw new ArgumentOutOfRangeException(nameof(context));
}
public LambdaExpressionSyntax ConvertLambdaExpression(CSS.AnonymousFunctionExpressionSyntax node, CS.CSharpSyntaxNode body, IEnumerable <ParameterSyntax> parameters, SyntaxTokenList modifiers)
{
var symbol = (IMethodSymbol)ModelExtensions.GetSymbolInfo(_semanticModel, node).Symbol;
var parameterList = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters.Select(p => (Microsoft.CodeAnalysis.VisualBasic.Syntax.ParameterSyntax)p.Accept(_nodesVisitor))));
LambdaHeaderSyntax header;
EndBlockStatementSyntax endBlock;
SyntaxKind multiLineExpressionKind;
SyntaxKind singleLineExpressionKind;
bool isSub = symbol.ReturnsVoid;
if (isSub)
{
header = SyntaxFactory.SubLambdaHeader(SyntaxFactory.List <AttributeListSyntax>(),
ConvertModifiers(modifiers, TokenContext.Local), parameterList, null);
endBlock = SyntaxFactory.EndBlockStatement(SyntaxKind.EndSubStatement,
SyntaxFactory.Token(SyntaxKind.SubKeyword));
multiLineExpressionKind = SyntaxKind.MultiLineSubLambdaExpression;
singleLineExpressionKind = SyntaxKind.SingleLineSubLambdaExpression;
}
else
{
header = CreateFunctionHeader(modifiers, parameterList, out endBlock, out multiLineExpressionKind);
singleLineExpressionKind = SyntaxKind.SingleLineFunctionLambdaExpression;
}
SyntaxList <StatementSyntax> statements;
if (body is CSS.BlockSyntax block)
{
statements = ConvertStatements(block.Statements);
}
else if (body.Kind() == CSSyntaxKind.ThrowExpression)
{
var csThrowExpression = (CSS.ThrowExpressionSyntax)body;
var vbThrowExpression = (ExpressionSyntax)csThrowExpression.Expression.Accept(_nodesVisitor);
var vbThrowStatement = SyntaxFactory.ThrowStatement(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), vbThrowExpression);
return(SyntaxFactory.MultiLineFunctionLambdaExpression(header,
SyntaxFactory.SingletonList <StatementSyntax>(vbThrowStatement), endBlock));
}
else
{
var stmt = GetStatementSyntax(body.Accept(_nodesVisitor),
expression => isSub ? (StatementSyntax)SyntaxFactory.ExpressionStatement(expression) : SyntaxFactory.ReturnStatement(expression));
statements = InsertRequiredDeclarations(SyntaxFactory.SingletonList(stmt), body);
}
return(CreateLambdaExpression(singleLineExpressionKind, multiLineExpressionKind, header, statements, endBlock));
}
public override VB.VisualBasicSyntaxNode VisitQualifiedCref(CSS.QualifiedCrefSyntax QualifiedCref)
{
var IdentifierOrTypeName = QualifiedCref.Container.Accept(this);
VBS.CrefReferenceSyntax Value = (VBS.CrefReferenceSyntax)QualifiedCref.Member.Accept(this);
VBS.NameSyntax Identifier;
Identifier = IdentifierOrTypeName is VBS.NameSyntax ? (VBS.NameSyntax)IdentifierOrTypeName : VBFactory.IdentifierName(IdentifierOrTypeName.ToString());
var QualifiedNameSyntax = VBFactory.QualifiedName(left: Identifier, global::VisualBasicSyntaxFactory.DotToken, right: (VBS.SimpleNameSyntax)Value.Name);
if (Value.Signature == null)
{
return(QualifiedNameSyntax);
}
return(VBFactory.CrefReference(QualifiedNameSyntax, Value.Signature, null));
}
SyntaxList <StatementSyntax> ConvertSwitchSectionBlock(CSS.SwitchSectionSyntax section)
{
List <StatementSyntax> statements = new List <StatementSyntax>();
var lastStatement = section.Statements.LastOrDefault();
foreach (var s in section.Statements)
{
if (s == lastStatement && s is CSS.BreakStatementSyntax)
{
continue;
}
statements.AddRange(ConvertBlock(s));
}
return(SyntaxFactory.List(statements));
}
public void ConvertBaseList(BaseTypeDeclarationSyntax type, List <InheritsStatementSyntax> inherits, List <ImplementsStatementSyntax> implements)
{
TypeSyntax[] arr;
switch (type.Kind())
{
case Microsoft.CodeAnalysis.CSharp.SyntaxKind.ClassDeclaration:
var classOrInterface = type.BaseList?.Types.FirstOrDefault()?.Type;
if (classOrInterface == null)
{
return;
}
var classOrInterfaceSymbol = ModelExtensions.GetSymbolInfo(_semanticModel, classOrInterface).Symbol;
if (classOrInterfaceSymbol?.IsInterfaceType() == true)
{
arr = type.BaseList?.Types.Select(t => (TypeSyntax)t.Type.Accept(_nodesVisitor)).ToArray();
if (arr.Length > 0)
{
implements.Add(SyntaxFactory.ImplementsStatement(arr));
}
}
else
{
inherits.Add(SyntaxFactory.InheritsStatement((TypeSyntax)classOrInterface.Accept(_nodesVisitor)));
arr = type.BaseList?.Types.Skip(1).Select(t => (TypeSyntax)t.Type.Accept(_nodesVisitor)).ToArray();
if (arr.Length > 0)
{
implements.Add(SyntaxFactory.ImplementsStatement(arr));
}
}
break;
case Microsoft.CodeAnalysis.CSharp.SyntaxKind.StructDeclaration:
arr = type.BaseList?.Types.Select(t => (TypeSyntax)t.Type.Accept(_nodesVisitor)).ToArray();
if (arr?.Length > 0)
{
implements.Add(SyntaxFactory.ImplementsStatement(arr));
}
break;
case Microsoft.CodeAnalysis.CSharp.SyntaxKind.InterfaceDeclaration:
arr = type.BaseList?.Types.Select(t => (TypeSyntax)t.Type.Accept(_nodesVisitor)).ToArray();
if (arr?.Length > 0)
{
inherits.Add(SyntaxFactory.InheritsStatement(arr));
}
break;
}
}
public override VB.VisualBasicSyntaxNode VisitNameMemberCref(CSS.NameMemberCrefSyntax node)
{
var Name = node.Name.Accept(this);
var CrefParameters = new List<VBS.CrefSignaturePartSyntax>();
VBS.CrefSignatureSyntax Signature = null;
if (node.Parameters != null)
{
foreach (CSS.CrefParameterSyntax p in node.Parameters.Parameters)
{
VBS.TypeSyntax TypeSyntax1 = (VBS.TypeSyntax)p.Accept(this);
CrefParameters.Add(VBFactory.CrefSignaturePart(modifier: default(SyntaxToken), TypeSyntax1));
}
Signature = VBFactory.CrefSignature(CrefParameters.ToArray());
}
return VBFactory.CrefReference((VBS.TypeSyntax)Name, signature: Signature, asClause: null);
}
IEnumerable <CaseBlockSyntax> AddLabels(CaseBlockSyntax[] blocks, List <VisualBasicSyntaxNode> gotoLabels)
{
foreach (var _block in blocks)
{
var block = _block;
foreach (var caseClause in block.CaseStatement.Cases)
{
var expression = caseClause is ElseCaseClauseSyntax ? (VisualBasicSyntaxNode)caseClause : ((SimpleCaseClauseSyntax)caseClause).Value;
if (gotoLabels.Any(label => label.IsEquivalentTo(expression)))
{
block = block.WithStatements(block.Statements.Insert(0, SyntaxFactory.LabelStatement(MakeGotoSwitchLabel(expression))));
}
}
yield return(block);
}
}
public override VB.VisualBasicSyntaxNode VisitXmlElement(CSS.XmlElementSyntax node)
{
var Content = new SyntaxList <VBS.XmlNodeSyntax>();
VBS.XmlElementStartTagSyntax StartTag = (VBS.XmlElementStartTagSyntax)node.StartTag.Accept(this);
bool NoEndTag = string.IsNullOrWhiteSpace(node.EndTag.Name.LocalName.ValueText);
var EndTag = NoEndTag ? VBFactory.XmlElementEndTag(((VBS.XmlNameSyntax)StartTag.Name)) : VBFactory.XmlElementEndTag((VBS.XmlNameSyntax)node.EndTag.Name.Accept(this));
try
{
for (int i = 0, loopTo = node.Content.Count - 1; i <= loopTo; i++)
{
var C = node.Content[i];
VBS.XmlNodeSyntax Node1 = (VBS.XmlNodeSyntax)C.Accept(this);
if (NoEndTag)
{
var LastToken = Node1.GetLastToken();
if (LastToken.ValueText.IsNewLine())
{
Node1 = Node1.ReplaceToken(LastToken, default(SyntaxToken));
}
}
Content = Content.Add(Node1);
}
if (node.EndTag?.HasLeadingTrivia == true && node.EndTag.GetLeadingTrivia()[0].IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia) == true)
{
var NewLeadingTriviaList = new SyntaxTriviaList();
NewLeadingTriviaList = NewLeadingTriviaList.Add(VBFactory.DocumentationCommentExteriorTrivia(node.EndTag.GetLeadingTrivia()[0].ToString().Replace("///", "'''")));
var NewTokenList = new SyntaxTokenList();
NewTokenList = NewTokenList.Add(VBFactory.XmlTextLiteralToken(NewLeadingTriviaList, " ", " ", new SyntaxTriviaList()));
Content = Content.Add(VBFactory.XmlText(NewTokenList));
EndTag = EndTag.WithoutLeadingTrivia();
}
}
catch (OperationCanceledException ex)
{
throw;
}
catch (Exception ex)
{
}
var XmlElement = VBFactory.XmlElement(StartTag, Content, EndTag);
return(XmlElement);
}
public override SyntaxList <StatementSyntax> VisitIfStatement(CSS.IfStatementSyntax node)
{
IdentifierNameSyntax name;
List <ArgumentSyntax> arguments = new List <ArgumentSyntax>();
StatementSyntax stmt;
if (node.Else == null && TryConvertRaiseEvent(node, out name, arguments))
{
stmt = SyntaxFactory.RaiseEventStatement(name, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments)));
return(SyntaxFactory.SingletonList(stmt));
}
var elseIfBlocks = new List <ElseIfBlockSyntax>();
ElseBlockSyntax elseBlock = null;
CollectElseBlocks(node, elseIfBlocks, ref elseBlock);
if (node.Statement is CSS.BlockSyntax)
{
stmt = SyntaxFactory.MultiLineIfBlock(
SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
ConvertBlock(node.Statement),
SyntaxFactory.List(elseIfBlocks),
elseBlock
);
}
else
{
if (elseIfBlocks.Any() || elseBlock != null || !IsSimpleStatement(node.Statement))
{
stmt = SyntaxFactory.MultiLineIfBlock(
SyntaxFactory.IfStatement((ExpressionSyntax)node.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
ConvertBlock(node.Statement),
SyntaxFactory.List(elseIfBlocks),
elseBlock
);
}
else
{
stmt = SyntaxFactory.SingleLineIfStatement(
(ExpressionSyntax)node.Condition.Accept(_nodesVisitor),
ConvertBlock(node.Statement),
null
).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword));
}
}
return(SyntaxFactory.SingletonList(stmt));
}
public override VB.VisualBasicSyntaxNode VisitXmlEmptyElement(CSS.XmlEmptyElementSyntax node)
{
try
{
VBS.XmlNodeSyntax Name = (VBS.XmlNodeSyntax)node.Name.Accept(this);
var ListOfAttributes = GatherAttributes(node.Attributes);
return(VBFactory.XmlEmptyElement(Name, ListOfAttributes));
}
catch (OperationCanceledException ex)
{
throw;
}
catch (Exception ex)
{
return(VBFactory.XmlText(node.GetText().ToString()));
}
}
public static SyntaxToken ConvertIdentifier(SyntaxToken id)
{
var idText = id.ValueText;
// Underscore is a special character in VB lexer which continues lines - not sure where to find the whole set of other similar tokens if any
// Rather than a complicated contextual rename, just add an extra dash to all identifiers and hope this method is consistently used
if (idText.All(c => c == '_'))
{
idText += "_";
}
if (IsKeywordThatNeedsEscaped(id))
{
return(SyntaxFactory.Identifier("[" + idText + "]"));
}
return(SyntaxFactory.Identifier(idText));
}
public override SyntaxList <StatementSyntax> VisitUsingStatement(CSS.UsingStatementSyntax node)
{
UsingStatementSyntax stmt;
if (node.Declaration == null)
{
stmt = SyntaxFactory.UsingStatement(
(ExpressionSyntax)node.Expression?.Accept(_nodesVisitor),
SyntaxFactory.SeparatedList <VariableDeclaratorSyntax>()
);
}
else
{
stmt = SyntaxFactory.UsingStatement(null, _commonConversions.RemodelVariableDeclaration(node.Declaration));
}
return(SyntaxFactory.SingletonList <StatementSyntax>(SyntaxFactory.UsingBlock(stmt, ConvertBlock(node.Statement))));
}
public override SyntaxList <StatementSyntax> VisitSwitchStatement(CSS.SwitchStatementSyntax node)
{
StatementSyntax stmt;
_blockInfo.Push(new BlockInfo());
try {
var blocks = node.Sections.OrderBy(IsDefaultSwitchStatement).Select(ConvertSwitchSection).ToArray();
stmt = SyntaxFactory.SelectBlock(
SyntaxFactory.SelectStatement((ExpressionSyntax)node.Expression.Accept(_nodesVisitor)).WithCaseKeyword(SyntaxFactory.Token(SyntaxKind.CaseKeyword)),
SyntaxFactory.List(AddLabels(blocks, _blockInfo.Peek().GotoCaseExpressions))
);
_switchCount++;
} finally {
_blockInfo.Pop();
}
return(SyntaxFactory.SingletonList(stmt));
}
public LambdaExpressionSyntax ConvertLambdaExpression(AnonymousFunctionExpressionSyntax node, CSharpSyntaxNode body, IEnumerable <ParameterSyntax> parameters, SyntaxTokenList modifiers)
{
var symbol = ModelExtensions.GetSymbolInfo(_semanticModel, node).Symbol as IMethodSymbol;
var parameterList = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters.Select(p => (Microsoft.CodeAnalysis.VisualBasic.Syntax.ParameterSyntax)p.Accept(_nodesVisitor))));
LambdaHeaderSyntax header;
EndBlockStatementSyntax endBlock;
SyntaxKind multiLineExpressionKind;
SyntaxKind singleLineExpressionKind;
if (symbol.ReturnsVoid)
{
header = SyntaxFactory.SubLambdaHeader(SyntaxFactory.List <AttributeListSyntax>(),
ConvertModifiers(modifiers, SyntaxKindExtensions.TokenContext.Local), parameterList, null);
endBlock = SyntaxFactory.EndBlockStatement(SyntaxKind.EndSubStatement,
SyntaxFactory.Token(SyntaxKind.SubKeyword));
multiLineExpressionKind = SyntaxKind.MultiLineSubLambdaExpression;
singleLineExpressionKind = SyntaxKind.SingleLineSubLambdaExpression;
}
else
{
header = CreateFunctionHeader(modifiers, parameterList, out endBlock, out multiLineExpressionKind);
singleLineExpressionKind = SyntaxKind.SingleLineFunctionLambdaExpression;
}
SyntaxList <StatementSyntax> statements;
if (body is BlockSyntax block)
{
statements = ConvertStatements(block.Statements);
}
else
{
statements = InsertRequiredDeclarations(
SyntaxFactory.SingletonList <StatementSyntax>(
SyntaxFactory.ReturnStatement((ExpressionSyntax)body.Accept(_nodesVisitor))),
body);
}
if (statements.Count == 1 && UnpackExpressionFromStatement(statements[0], out var expression))
{
return(SyntaxFactory.SingleLineLambdaExpression(singleLineExpressionKind, header, expression));
}
return(SyntaxFactory.MultiLineLambdaExpression(multiLineExpressionKind, header, statements, endBlock));
}
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?Literal(true) : (ExpressionSyntax)node.Condition.Accept(nodesVisitor);
block = SyntaxFactory.WhileBlock(
SyntaxFactory.WhileStatement(condition),
stmts
);
return(SyntaxFactory.List(node.Initializers.Select(ConvertSingleExpression)).Add(block));
}
return(SyntaxFactory.SingletonList(block));
}
private StatementSyntax WrapRootExpression(ExpressionSyntax expressionSyntax)
{
InvocationExpressionSyntax invocationExpression = expressionSyntax as InvocationExpressionSyntax;
if (invocationExpression != null)
{
var lastExpression = expressionSyntax.FollowProperty(exp => exp.TypeSwitch(
(InvocationExpressionSyntax e) => e.Expression,
(ParenthesizedExpressionSyntax e) => e.Expression,
(CastExpressionSyntax e) => e.Expression,
(MemberAccessExpressionSyntax e) => e.Expression
)).LastOrDefault();
if (lastExpression != null && !(lastExpression is IdentifierNameSyntax || lastExpression is InstanceExpressionSyntax))
{
return(SyntaxFactory.CallStatement(expressionSyntax));
}
}
return(SyntaxFactory.ExpressionStatement(expressionSyntax));
}
private static SyntaxToken CSharpDefaultVisibility(TokenContext context)
{
switch (context)
{
case TokenContext.Global:
case TokenContext.InterfaceOrModule:
return(SyntaxFactory.Token(SyntaxKind.FriendKeyword));
case TokenContext.Local:
case TokenContext.MemberInClass:
case TokenContext.MemberInModule:
case TokenContext.MemberInStruct:
return(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
case TokenContext.MemberInInterface:
return(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
}
throw new ArgumentOutOfRangeException(nameof(context));
}
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));
}
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> VisitBreakStatement(CSS.BreakStatementSyntax node)
{
var statementKind = SyntaxKind.None;
var keywordKind = SyntaxKind.None;
foreach (var stmt in node.GetAncestors <CSS.StatementSyntax>())
{
if (stmt is CSS.DoStatementSyntax)
{
statementKind = SyntaxKind.ExitDoStatement;
keywordKind = SyntaxKind.DoKeyword;
break;
}
if (stmt is CSS.WhileStatementSyntax)
{
statementKind = SyntaxKind.ExitWhileStatement;
keywordKind = SyntaxKind.WhileKeyword;
break;
}
if (stmt is CSS.ForEachStatementSyntax)
{
statementKind = SyntaxKind.ExitForStatement;
keywordKind = SyntaxKind.ForKeyword;
break;
}
if (stmt is CSS.ForStatementSyntax fs)
{
bool isFor = ConvertForToSimpleForNextWithoutStatements(fs, out _);
statementKind = isFor ? SyntaxKind.ExitForStatement : SyntaxKind.ExitWhileStatement;
keywordKind = isFor ? SyntaxKind.ForKeyword : SyntaxKind.WhileKeyword;
break;
}
if (stmt is CSS.SwitchStatementSyntax)
{
statementKind = SyntaxKind.ExitSelectStatement;
keywordKind = SyntaxKind.SelectKeyword;
break;
}
}
return(SyntaxFactory.SingletonList <StatementSyntax>(SyntaxFactory.ExitStatement(statementKind, SyntaxFactory.Token(keywordKind))));
}
private VariableDeclaratorSyntax ConvertToVariableDeclarator(DeclarationExpressionSyntax des)
{
var id = ((IdentifierNameSyntax)des.Accept(_nodesVisitor)).Identifier;
var ids = SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(id));
TypeSyntax typeSyntax;
if (des.Type.IsVar)
{
var typeSymbol = (ITypeSymbol)ModelExtensions.GetSymbolInfo(_semanticModel, des.Type).ExtractBestMatch();
typeSyntax = typeSymbol.ToVbSyntax(_semanticModel, des.Type);
}
else
{
typeSyntax = (TypeSyntax)des.Type.Accept(_nodesVisitor);
}
var simpleAsClauseSyntax = SyntaxFactory.SimpleAsClause(typeSyntax);
var equalsValueSyntax = SyntaxFactory.EqualsValue(SyntaxFactory.LiteralExpression(SyntaxKind.NothingLiteralExpression, SyntaxFactory.Token(SyntaxKind.NothingKeyword)));
return(SyntaxFactory.VariableDeclarator(ids, simpleAsClauseSyntax, equalsValueSyntax));
}
public SyntaxList <StatementSyntax> ConvertBody(BlockSyntax body,
ArrowExpressionClauseSyntax expressionBody, MethodBodyVisitor iteratorState = null)
{
if (body != null)
{
return(ConvertStatements(body.Statements, iteratorState));
}
if (expressionBody != null)
{
var convertedBody = expressionBody.Expression.Accept(_nodesVisitor);
if (convertedBody is ExpressionSyntax convertedBodyExpression)
{
convertedBody = SyntaxFactory.ReturnStatement(convertedBodyExpression);
}
return(SyntaxFactory.SingletonList((StatementSyntax)convertedBody));
}
return(SyntaxFactory.List <StatementSyntax>());
}
public override VB.VisualBasicSyntaxNode VisitPredefinedType(CSS.PredefinedTypeSyntax node)
{
var Token = VBUtil.ConvertTypesTokenToKind(CS.CSharpExtensions.Kind(node.Keyword), true);
var switchExpr = Token.RawKind;
switch (switchExpr)
{
case (int)VB.SyntaxKind.EmptyToken:
{
return VBFactory.ParseTypeName(node.ToString());
}
case (int)VB.SyntaxKind.NothingKeyword:
{
return global::VisualBasicSyntaxFactory.NothingExpression;
}
default:
{
return VBFactory.PredefinedType(Token);
}
}
}
void CollectElseBlocks(CSS.IfStatementSyntax node, List <ElseIfBlockSyntax> elseIfBlocks, ref ElseBlockSyntax elseBlock)
{
if (node.Else == null)
{
return;
}
if (node.Else.Statement is CSS.IfStatementSyntax)
{
var elseIf = (CSS.IfStatementSyntax)node.Else.Statement;
elseIfBlocks.Add(
SyntaxFactory.ElseIfBlock(
SyntaxFactory.ElseIfStatement((ExpressionSyntax)elseIf.Condition.Accept(_nodesVisitor)).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)),
ConvertBlock(elseIf.Statement)
)
);
CollectElseBlocks(elseIf, elseIfBlocks, ref elseBlock);
}
else
{
elseBlock = SyntaxFactory.ElseBlock(ConvertBlock(node.Else.Statement));
}
}
private VariableDeclaratorSyntax ConvertToVariableDeclarator(CSS.PropertyDeclarationSyntax des)
{
var id = GetVbPropertyBackingFieldName(des);
var ids = SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(id));
TypeSyntax typeSyntax;
if (des.Type.IsVar)
{
var typeSymbol = ModelExtensions.GetSymbolInfo(_semanticModel, des.Type).ExtractBestMatch <ITypeSymbol>();
typeSyntax = typeSymbol?.ToVbSyntax(_semanticModel, des.Type);
}
else
{
typeSyntax = (TypeSyntax)des.Type.Accept(_nodesVisitor);
}
var simpleAsClauseSyntax = typeSyntax != null?SyntaxFactory.SimpleAsClause(typeSyntax) : null; //Gracefully degrade when no type information available
EqualsValueSyntax equalsValueSyntax = null;
return(SyntaxFactory.VariableDeclarator(ids, simpleAsClauseSyntax, equalsValueSyntax));
}
private VariableDeclaratorSyntax ConvertToVariableDeclaratorOrNull(CSS.IsPatternExpressionSyntax node)
{
switch (node.Pattern)
{
case CSS.DeclarationPatternSyntax d: {
var id = ((IdentifierNameSyntax)d.Designation.Accept(_nodesVisitor)).Identifier;
var ids = SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(id));
TypeSyntax right = (TypeSyntax)d.Type.Accept(_nodesVisitor);
var simpleAsClauseSyntax = SyntaxFactory.SimpleAsClause(right);
var equalsValueSyntax = SyntaxFactory.EqualsValue(
SyntaxFactory.LiteralExpression(SyntaxKind.NothingLiteralExpression,
SyntaxFactory.Token(SyntaxKind.NothingKeyword)));
return(SyntaxFactory.VariableDeclarator(ids, simpleAsClauseSyntax, equalsValueSyntax));
}
case CSS.ConstantPatternSyntax _:
return(null);
default:
throw new ArgumentOutOfRangeException(nameof(node.Pattern), node.Pattern, null);
}
}