static SeparatedSyntaxList <VariableDeclaratorSyntax> RemodelVariableDeclaration(CSS.VariableDeclarationSyntax declaration, CS.CSharpSyntaxVisitor <VisualBasicSyntaxNode> nodesVisitor)
{
var type = (TypeSyntax)declaration.Type.Accept(nodesVisitor);
var declaratorsWithoutInitializers = new List <CSS.VariableDeclaratorSyntax>();
var declarators = new List <VariableDeclaratorSyntax>();
foreach (var v in declaration.Variables)
{
if (v.Initializer == null)
{
declaratorsWithoutInitializers.Add(v);
continue;
}
else
{
declarators.Add(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.SingletonSeparatedList(ExtractIdentifier(v)),
declaration.Type.IsVar ? null : SyntaxFactory.SimpleAsClause(type),
SyntaxFactory.EqualsValue((ExpressionSyntax)v.Initializer.Value.Accept(nodesVisitor))
)
);
}
}
if (declaratorsWithoutInitializers.Count > 0)
{
declarators.Insert(0, SyntaxFactory.VariableDeclarator(SyntaxFactory.SeparatedList(declaratorsWithoutInitializers.Select(ExtractIdentifier)), SyntaxFactory.SimpleAsClause(type), null));
}
return(SyntaxFactory.SeparatedList(declarators));
}
internal SeparatedSyntaxList <VariableDeclaratorSyntax> RemodelVariableDeclaration(VariableDeclarationSyntax declaration)
{
var visualBasicSyntaxNode = declaration.Type.Accept(_nodesVisitor);
var type = (TypeSyntax)visualBasicSyntaxNode;
var declaratorsWithoutInitializers = new List <Microsoft.CodeAnalysis.CSharp.Syntax.VariableDeclaratorSyntax>();
var declarators = new List <VariableDeclaratorSyntax>();
foreach (var v in declaration.Variables)
{
if (v.Initializer == null)
{
declaratorsWithoutInitializers.Add(v);
}
else
{
declarators.Add(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.SingletonSeparatedList(ExtractIdentifier(v)),
declaration.Type.IsVar ? null : SyntaxFactory.SimpleAsClause(type),
SyntaxFactory.EqualsValue((ExpressionSyntax)ConvertTopLevelExpression(v.Initializer.Value))
)
);
}
}
if (declaratorsWithoutInitializers.Count > 0)
{
declarators.Insert(0, SyntaxFactory.VariableDeclarator(SyntaxFactory.SeparatedList(declaratorsWithoutInitializers.Select(ExtractIdentifier)), SyntaxFactory.SimpleAsClause(type), null));
}
return(SyntaxFactory.SeparatedList(declarators));
}
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> 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()));
}
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));
}
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);
}
}
private VariableDeclaratorSyntax ConvertToVariableDeclarator(CSSyntax.DeclarationExpressionSyntax des)
{
var id = ((IdentifierNameSyntax)des.Accept(_nodesVisitor)).Identifier;
var ids = SyntaxFactory.SingletonSeparatedList(SyntaxFactory.ModifiedIdentifier(id));
TypeSyntax typeSyntax;
if (des.Type.IsVar)
{
typeSyntax = _semanticModel.GetSymbolInfo(des.Type).ExtractBestMatch <ITypeSymbol>() is { } typeSymbol
? (TypeSyntax)VbSyntaxGenerator.TypeExpression(typeSymbol)
: null;
}
else
{
typeSyntax = (TypeSyntax)des.Type.Accept(_nodesVisitor);
}
var simpleAsClauseSyntax = typeSyntax != null?SyntaxFactory.SimpleAsClause(typeSyntax) : null; //Gracefully degrade when no type information available
var equalsValueSyntax = SyntaxFactory.EqualsValue(SyntaxFactory.LiteralExpression(SyntaxKind.NothingLiteralExpression, SyntaxFactory.Token(SyntaxKind.NothingKeyword)));
return(SyntaxFactory.VariableDeclarator(ids, simpleAsClauseSyntax, equalsValueSyntax));
}
