public int Nodes()
{
NodesVisitor v = new NodesVisitor();
Visit(root, v);
return(v.nodes);
}
public static async Task <SyntaxNode> ConvertCompilationTree(Document document,
VisualBasicCompilation vbViewOfCsSymbols, Project vbReferenceProject, CancellationToken cancellationToken)
{
document = await document.WithExpandedRootAsync(cancellationToken);
var compilation = await document.Project.GetCompilationAsync(cancellationToken);
var tree = await document.GetSyntaxTreeAsync(cancellationToken);
var semanticModel = compilation.GetSemanticModel(tree, true);
var root = await document.GetSyntaxRootAsync(cancellationToken) as CSS.CompilationUnitSyntax ??
throw new InvalidOperationException(NullRootError(document));
var vbSyntaxGenerator = SyntaxGenerator.GetGenerator(vbReferenceProject);
var numberOfLines = tree.GetLineSpan(root.FullSpan).EndLinePosition.Line;
var visualBasicSyntaxVisitor = new NodesVisitor(document, (CS.CSharpCompilation)compilation, semanticModel, vbViewOfCsSymbols, vbSyntaxGenerator, numberOfLines);
var converted = (VBSyntax.CompilationUnitSyntax)root.Accept(visualBasicSyntaxVisitor.TriviaConvertingVisitor);
try {
// This call is very expensive for large documents. Should look for a more performant version, e.g. Is NormalizeWhitespace good enough?
converted = (VBSyntax.CompilationUnitSyntax)Formatter.Format(converted, document.Project.Solution.Workspace, cancellationToken: cancellationToken);
return(LineTriviaMapper.MapSourceTriviaToTarget(root, converted));
} catch (Exception) { //TODO log
return(converted);
}
}
static SeparatedSyntaxList<VariableDeclaratorSyntax> RemodelVariableDeclaration(CSS.VariableDeclarationSyntax declaration, NodesVisitor 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);
}
static Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations(VBSyntax.VariableDeclaratorSyntax declarator, VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor, SemanticModel semanticModel)
{
var rawType = (TypeSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax c) => c.Type,
(VBSyntax.AsNewClauseSyntax c) => VBasic.SyntaxExtensions.Type(c.NewExpression),
_ => { throw new NotImplementedException($"{_.GetType().FullName} not implemented!"); }
)?.Accept(nodesVisitor) ?? SyntaxFactory.ParseTypeName("var");
var initializer = (ExpressionSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax _) => declarator.Initializer?.Value,
(VBSyntax.AsNewClauseSyntax c) => c.NewExpression
)?.Accept(nodesVisitor) ?? (ExpressionSyntax)declarator.Initializer?.Value.Accept(nodesVisitor);
var newDecls = new Dictionary <string, VariableDeclarationSyntax>();
foreach (var name in declarator.Names)
{
var type = rawType;
if (!SyntaxTokenExtensions.IsKind(name.Nullable, VBasic.SyntaxKind.None))
{
if (type is ArrayTypeSyntax)
{
type = ((ArrayTypeSyntax)type).WithElementType(
SyntaxFactory.NullableType(((ArrayTypeSyntax)type).ElementType));
initializer = null;
}
else
{
type = SyntaxFactory.NullableType(type);
}
}
var rankSpecifiers = NodesVisitor.ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, nodesVisitor, semanticModel, false);
if (rankSpecifiers.Count > 0)
{
var rankSpecifiersWithSizes = NodesVisitor.ConvertArrayRankSpecifierSyntaxes(name.ArrayRankSpecifiers, name.ArrayBounds, nodesVisitor, semanticModel);
if (!rankSpecifiersWithSizes.SelectMany(ars => ars.Sizes).OfType <OmittedArraySizeExpressionSyntax>().Any())
{
initializer =
SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(type, rankSpecifiersWithSizes));
}
type = SyntaxFactory.ArrayType(type, rankSpecifiers);
}
VariableDeclarationSyntax decl;
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier, semanticModel), null, initializer == null ? null : SyntaxFactory.EqualsValueClause(initializer));
string k = type.ToString();
if (newDecls.TryGetValue(k, out decl))
{
newDecls[k] = decl.AddVariables(v);
}
else
{
newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
}
}
return(newDecls);
}
public static async Task <SyntaxNode> ConvertCompilationTree(Document document)
{
var compilation = await document.Project.GetCompilationAsync();
var tree = await document.GetSyntaxTreeAsync();
var semanticModel = compilation.GetSemanticModel(tree, true);
var root = (CS.CSharpSyntaxNode) await document.GetSyntaxRootAsync();
var visualBasicSyntaxVisitor = new NodesVisitor(semanticModel);
return(root.Accept(visualBasicSyntaxVisitor.TriviaConvertingVisitor));
}
public static async Task <SyntaxNode> ConvertCompilationTree(Document document,
VisualBasicCompilation vbViewOfCsSymbols, Project vbReferenceProject)
{
var compilation = await document.Project.GetCompilationAsync();
var tree = await document.GetSyntaxTreeAsync();
var semanticModel = compilation.GetSemanticModel(tree, true);
var root = (CS.CSharpSyntaxNode) await document.GetSyntaxRootAsync();
var vbSyntaxGenerator = SyntaxGenerator.GetGenerator(vbReferenceProject);
var visualBasicSyntaxVisitor = new NodesVisitor(document, (CS.CSharpCompilation)compilation, semanticModel, vbViewOfCsSymbols, vbSyntaxGenerator);
return(root.Accept(visualBasicSyntaxVisitor.TriviaConvertingVisitor));
}
public static async Task <SyntaxNode> ConvertCompilationTreeAsync(Document document,
VisualBasicCompilation vbViewOfCsSymbols, Project vbReferenceProject, OptionalOperations optionalOperations, CancellationToken cancellationToken)
{
document = await document.WithExpandedRootAsync(cancellationToken);
var compilation = await document.Project.GetCompilationAsync(cancellationToken);
var tree = await document.GetSyntaxTreeAsync(cancellationToken);
var semanticModel = compilation.GetSemanticModel(tree, true);
var root = await document.GetSyntaxRootAsync(cancellationToken) as CSS.CompilationUnitSyntax ??
throw new InvalidOperationException(NullRootError(document));
var vbSyntaxGenerator = SyntaxGenerator.GetGenerator(vbReferenceProject);
var numberOfLines = tree.GetLineSpan(root.FullSpan).EndLinePosition.Line;
var visualBasicSyntaxVisitor = new NodesVisitor(document, (CS.CSharpCompilation)compilation, semanticModel, vbViewOfCsSymbols, vbSyntaxGenerator, numberOfLines);
var converted = (VBSyntax.CompilationUnitSyntax)root.Accept(visualBasicSyntaxVisitor.TriviaConvertingVisitor);
return(optionalOperations.MapSourceTriviaToTargetHandled(root, converted, document));
}
static Dictionary<string, VariableDeclarationSyntax> SplitVariableDeclarations(VBSyntax.VariableDeclaratorSyntax declarator, NodesVisitor nodesVisitor, SemanticModel semanticModel)
{
var rawType = (TypeSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax c) => c.Type,
(VBSyntax.AsNewClauseSyntax c) => VBasic.SyntaxExtensions.Type(c.NewExpression),
_ => { throw new NotImplementedException($"{_.GetType().FullName} not implemented!"); }
)?.Accept(nodesVisitor) ?? SyntaxFactory.ParseTypeName("var");
var initializer = (ExpressionSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax _) => declarator.Initializer?.Value,
(VBSyntax.AsNewClauseSyntax c) => c.NewExpression
)?.Accept(nodesVisitor) ?? (ExpressionSyntax)declarator.Initializer?.Value.Accept(nodesVisitor);
var newDecls = new Dictionary<string, VariableDeclarationSyntax>();
foreach (var name in declarator.Names)
{
var type = rawType;
if (!name.Nullable.IsKind(VBasic.SyntaxKind.None))
{
if (type is ArrayTypeSyntax)
type = ((ArrayTypeSyntax)type).WithElementType(SyntaxFactory.NullableType(((ArrayTypeSyntax)type).ElementType));
else
type = SyntaxFactory.NullableType(type);
}
if (name.ArrayRankSpecifiers.Count > 0)
type = SyntaxFactory.ArrayType(type, SyntaxFactory.List(name.ArrayRankSpecifiers.Select(a => (ArrayRankSpecifierSyntax)a.Accept(nodesVisitor))));
VariableDeclarationSyntax decl;
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier, semanticModel), null, initializer == null ? null : SyntaxFactory.EqualsValueClause(initializer));
string k = type.ToString();
if (newDecls.TryGetValue(k, out decl))
newDecls[k] = decl.AddVariables(v);
else
newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
}
return newDecls;
}
public static VisualBasicSyntaxNode ConvertCompilationTree(CS.CSharpCompilation compilation, CS.CSharpSyntaxTree tree)
{
var visualBasicSyntaxVisitor = new NodesVisitor(compilation.GetSemanticModel(tree, true));
return(tree.GetRoot().Accept(visualBasicSyntaxVisitor.TriviaConvertingVisitor));
}
static SeparatedSyntaxList <VariableDeclaratorSyntax> RemodelVariableDeclaration(CSS.VariableDeclarationSyntax declaration, NodesVisitor 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));
}
public MethodBodyVisitor(SemanticModel semanticModel, NodesVisitor nodesVisitor)
{
this.semanticModel = semanticModel;
this.nodesVisitor = nodesVisitor;
}
public MethodBodyVisitor(SemanticModel semanticModel, NodesVisitor nodesVisitor, Stack <string> withBlockTempVariableNames)
{
this.semanticModel = semanticModel;
this.nodesVisitor = nodesVisitor;
this.withBlockTempVariableNames = withBlockTempVariableNames;
}
static Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations(VBSyntax.VariableDeclaratorSyntax declarator, NodesVisitor nodesVisitor, SemanticModel semanticModel)
{
var rawType = (TypeSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax c) => c.Type,
(VBSyntax.AsNewClauseSyntax c) => VBasic.SyntaxExtensions.Type(c.NewExpression),
_ => { throw new NotImplementedException($"{_.GetType().FullName} not implemented!"); }
)?.Accept(nodesVisitor) ?? SyntaxFactory.ParseTypeName("var");
var initializer = (ExpressionSyntax)declarator.AsClause?.TypeSwitch(
(VBSyntax.SimpleAsClauseSyntax _) => declarator.Initializer?.Value,
(VBSyntax.AsNewClauseSyntax c) => c.NewExpression
)?.Accept(nodesVisitor) ?? (ExpressionSyntax)declarator.Initializer?.Value.Accept(nodesVisitor);
if (initializer != null && rawType.IsVar == false)
{
if (initializer.IsKind(SyntaxKind.ObjectCreationExpression))
{
if (((ObjectCreationExpressionSyntax)initializer).Type.IsEquivalentTo(rawType))
{
//correct type
}
else
{
initializer = SyntaxFactory.CastExpression(rawType, initializer);
}
}
else
{
initializer = SyntaxFactory.CastExpression(rawType, initializer);
}
}
var newDecls = new Dictionary <string, VariableDeclarationSyntax>();
foreach (var name in declarator.Names)
{
var type = rawType;
if (!name.Nullable.IsKind(VBasic.SyntaxKind.None))
{
if (type is ArrayTypeSyntax)
{
type = ((ArrayTypeSyntax)type).WithElementType(SyntaxFactory.NullableType(((ArrayTypeSyntax)type).ElementType));
}
else
{
type = SyntaxFactory.NullableType(type);
}
}
if (name.ArrayRankSpecifiers.Count > 0)
{
type = SyntaxFactory.ArrayType(type, SyntaxFactory.List(name.ArrayRankSpecifiers.Select(a => (ArrayRankSpecifierSyntax)a.Accept(nodesVisitor))));
}
VariableDeclarationSyntax decl;
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier, semanticModel), null, initializer == null ? null : SyntaxFactory.EqualsValueClause(initializer));
string k = type.ToString();
if (newDecls.TryGetValue(k, out decl))
{
newDecls[k] = decl.AddVariables(v);
}
else
{
newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
}
}
return(newDecls);
}
