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; }