public MethodBodyVisitor(SemanticModel semanticModel, VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor, Stack <string> withBlockTempVariableNames, TriviaConverter triviaConverter)
{
this._semanticModel = semanticModel;
this._nodesVisitor = nodesVisitor;
this._withBlockTempVariableNames = withBlockTempVariableNames;
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(this, triviaConverter);
}
public ByRefParameterVisitor(VBasic.VisualBasicSyntaxVisitor <SyntaxList <StatementSyntax> > wrappedVisitor, AdditionalLocals additionalLocals,
SemanticModel semanticModel, HashSet <string> generatedNames)
{
_wrappedVisitor = wrappedVisitor;
_additionalLocals = additionalLocals;
_semanticModel = semanticModel;
_generatedNames = generatedNames;
}
public PerScopeStateVisitorDecorator(VBasic.VisualBasicSyntaxVisitor <Task <SyntaxList <StatementSyntax> > > wrappedVisitor, PerScopeState additionalLocals,
SemanticModel semanticModel, HashSet <string> generatedNames)
{
_wrappedVisitor = wrappedVisitor;
_additionalLocals = additionalLocals;
_semanticModel = semanticModel;
_generatedNames = generatedNames;
}
public MethodBodyVisitor(VBasic.VisualBasicSyntaxNode methodNode, SemanticModel semanticModel,
VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor,
Stack <string> withBlockTempVariableNames, HashSet <string> extraUsingDirectives,
TriviaConverter triviaConverter)
{
_methodNode = methodNode;
this._semanticModel = semanticModel;
this._nodesVisitor = nodesVisitor;
this._withBlockTempVariableNames = withBlockTempVariableNames;
_extraUsingDirectives = extraUsingDirectives;
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(this, triviaConverter);
CommonConversions = new CommonConversions(semanticModel, _nodesVisitor);
}
public MethodBodyVisitor(VBasic.VisualBasicSyntaxNode methodNode, SemanticModel semanticModel,
VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor, CommonConversions commonConversions,
Stack <string> withBlockTempVariableNames, HashSet <string> extraUsingDirectives,
AdditionalLocals additionalLocals, TriviaConverter triviaConverter)
{
_methodNode = methodNode;
_semanticModel = semanticModel;
_nodesVisitor = nodesVisitor;
CommonConversions = commonConversions;
_withBlockTempVariableNames = withBlockTempVariableNames;
_extraUsingDirectives = extraUsingDirectives;
var byRefParameterVisitor = new ByRefParameterVisitor(this, additionalLocals, semanticModel, _generatedNames);
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(byRefParameterVisitor, triviaConverter);
}
private static ExpressionSyntax IncreaseArrayUpperBoundExpression(VBSyntax.ExpressionSyntax expr, SemanticModel model, VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> commentConvertingNodesVisitor)
{
var constant = model.GetConstantValue(expr);
if (constant.HasValue && constant.Value is int)
{
return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal((int)constant.Value + 1)));
}
return(SyntaxFactory.BinaryExpression(
SyntaxKind.SubtractExpression,
(ExpressionSyntax)expr.Accept(commentConvertingNodesVisitor), SyntaxFactory.Token(SyntaxKind.PlusToken), SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1))));
}
public static IEnumerable <ExpressionSyntax> ConvertArrayBounds(VBSyntax.ArgumentListSyntax argumentListSyntax, SemanticModel model, VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> commentConvertingNodesVisitor)
{
return(argumentListSyntax.Arguments.Select(a => IncreaseArrayUpperBoundExpression(((VBSyntax.SimpleArgumentSyntax)a).Expression, model, commentConvertingNodesVisitor)));
}
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);
}
