public static String getAssignmentOrLocalVarName(SyntaxNode node)
{
AssignmentExpressionSyntax assignmentExpressionSyntax = node as AssignmentExpressionSyntax;
if (assignmentExpressionSyntax != null)
{
return(assignmentExpressionSyntax.Left.ToString());
}
LocalDeclarationStatementSyntax localDeclarationStatementSyntax = node as LocalDeclarationStatementSyntax;
if (localDeclarationStatementSyntax != null)
{
VariableDeclaratorSyntax variableDeclaratorSyntax = localDeclarationStatementSyntax.ChildNodes().First().ChildNodes().ElementAtOrDefault(1) as VariableDeclaratorSyntax;
if (variableDeclaratorSyntax != null)
{
return(variableDeclaratorSyntax.Identifier.ToString());
}
}
VariableDeclarationSyntax variableDeclarationSyntax = node as VariableDeclarationSyntax;
if (variableDeclarationSyntax != null)
{
VariableDeclaratorSyntax variableDeclaratorSyntax = variableDeclarationSyntax.ChildNodes().ElementAtOrDefault(1) as VariableDeclaratorSyntax;
if (variableDeclaratorSyntax != null)
{
return(variableDeclaratorSyntax.Identifier.ToString());
}
}
return(null);
}
static bool TryValidateLocalVariableType(LocalDeclarationStatementSyntax localDeclarationStatementSyntax, VariableDeclarationSyntax variableDeclarationSyntax)
{
//Either we don't have a local variable or we're using constant value
if (localDeclarationStatementSyntax == null ||
localDeclarationStatementSyntax.IsConst ||
localDeclarationStatementSyntax.ChildNodes().OfType <VariableDeclarationSyntax>().Count() != 1)
{
return(false);
}
//We don't want to raise a diagnostic if the local variable is already a var
return(!variableDeclarationSyntax.Type.IsVar);
}
private void liveVarHelper(SyntaxNode node, ISet <IdentifierNameSyntax> OutWithRemovedNodesRemoved)
{
CustomSyntaxVisitor visitor = new CustomSyntaxVisitor();
visitor.Visit(node);
if (visitor.isFor || visitor.isWhile || visitor.isIf)
{
//do nothing
}
else if (visitor.isAss)
{
//only dive into right side
AssignmentExpressionSyntax assignmentExpression = node as AssignmentExpressionSyntax;
ISet <IdentifierNameSyntax> uses = FindIdentifierNameSyntax(assignmentExpression.Right);
foreach (IdentifierNameSyntax lineUse in uses)
{
OutWithRemovedNodesRemoved.Add(lineUse);
}
}
else if (visitor.isLocalDec)
{
LocalDeclarationStatementSyntax localDeclarationStatement = node as LocalDeclarationStatementSyntax;
ISet <IdentifierNameSyntax> uses = FindIdentifierNameSyntax(localDeclarationStatement.ChildNodes().First().ChildNodes().ElementAtOrDefault(1).ChildNodes().First());
foreach (IdentifierNameSyntax lineUse in uses)
{
OutWithRemovedNodesRemoved.Add(lineUse);
}
}
else if (visitor.isVarDec)
{
VariableDeclarationSyntax variableDeclaration = node as VariableDeclarationSyntax;
ISet <IdentifierNameSyntax> uses = FindIdentifierNameSyntax(variableDeclaration.ChildNodes().ElementAtOrDefault(1).ChildNodes().First());
foreach (IdentifierNameSyntax lineUse in uses)
{
OutWithRemovedNodesRemoved.Add(lineUse);
}
}
else
{
//Dive into whole statement
ISet <IdentifierNameSyntax> uses = FindIdentifierNameSyntax(node);
if (uses.Count != 0)
{
foreach (IdentifierNameSyntax lineUse in uses)
{
OutWithRemovedNodesRemoved.Add(lineUse);
}
}
}
}
private async Task <Document> UseVarAsync(Document document, LocalDeclarationStatementSyntax localDeclaration, CancellationToken cancellationToken)
{
var variableDeclaration = localDeclaration.ChildNodes()
.OfType <VariableDeclarationSyntax>()
.FirstOrDefault();
var root = await document.GetSyntaxRootAsync(cancellationToken);
var @var = SyntaxFactory.IdentifierName("var")
.WithLeadingTrivia(variableDeclaration.Type.GetLeadingTrivia())
.WithTrailingTrivia(variableDeclaration.Type.GetTrailingTrivia());
var newRoot = root.ReplaceNode(variableDeclaration.Type, @var);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
var varDec = node.ChildNodes().OfType <VariableDeclarationSyntax>().FirstOrDefault();
PredefinedTypeSyntax predefType = null;
try
{
predefType = varDec.ChildNodes().OfType <PredefinedTypeSyntax>().Last();
} catch (InvalidOperationException)
{
return(base.VisitLocalDeclarationStatement(node).WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed));
}
var trivia = predefType.GetLeadingTrivia();
var predefTypeKind = predefType.ChildTokens().FirstOrDefault().Kind();
if (kindList.Contains(predefTypeKind))
{
Console.WriteLine("Zawiera");
}
var expr = varDec.ChildNodes().OfType <VariableDeclaratorSyntax>().FirstOrDefault()
.ChildNodes().OfType <EqualsValueClauseSyntax>().FirstOrDefault()
.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault();
var decl = varDec.ChildNodes().OfType <VariableDeclaratorSyntax>().FirstOrDefault();
var exprName = expr.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault();
var newRight = SyntaxFactory.TriviaList();
if (kindList.Contains(predefTypeKind) && exprName.ToString().Equals("Range"))
{
var argList = expr.ChildNodes().OfType <ArgumentListSyntax>().FirstOrDefault();
var argListCount = argList.ChildNodes().OfType <ArgumentSyntax>().Count();
if (argListCount == 2)
{
var arg1 = argList.ChildNodes().OfType <ArgumentSyntax>().FirstOrDefault();
var arg2 = argList.ChildNodes().OfType <ArgumentSyntax>().Last();
var right = new SyntaxNodeOrToken[5];
Console.WriteLine(arg1 + " : " + arg2);
int count = 0;
try
{
ExpandSnippet(arg1, arg2, ref right, ref count);
var newFieldDecl = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.ArrayType(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(predefTypeKind)))
.WithRankSpecifiers(
SyntaxFactory.SingletonList <ArrayRankSpecifierSyntax>(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression())))))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(decl.Identifier.ToString()))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ImplicitArrayCreationExpression(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
right))))))))
.NormalizeWhitespace();
node = node.ReplaceNode(node, newFieldDecl);
}
catch (FormatException)
{
return(base.VisitLocalDeclarationStatement(node).WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed));
}
}
}
return(base.VisitLocalDeclarationStatement(node).WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed).WithLeadingTrivia(SyntaxFactory.ElasticWhitespace(trivia.ToString())));
}
private Method TraverseVarDecls(LocalDeclarationStatementSyntax ldss)
{
Method retMethod = new Method();
List<Encapsulation> accessability = new List<Encapsulation>();
List<Qualifiers> qualifiers = new List<Qualifiers>();
foreach (SyntaxToken st in ldss.Modifiers)
{
string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
Encapsulation encap;
Qualifiers qual;
if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
{
accessability.Add(encap);
}
else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
{
qualifiers.Add(qual);
}
}
foreach (SyntaxNode ss in ldss.ChildNodes())
{
if (ss is VariableDeclaratorSyntax)
{
Variables retVar = new Variables();
retVar = TraverseVariableSyntax(ss as VariableDeclaratorSyntax, accessability, qualifiers);
retMethod.AccessedVariables.Add(retVar);
}
else if (ss is CallStatementSyntax)
{
retMethod.InvokedMethods.Add(TraverseInvokedMethod(ss as CallStatementSyntax));
}
}
return retMethod;
}
