protected override async Task RegisterCodeFixesAsync(DocumentEditorCodeFixContext context) { var document = context.Document; var syntaxRoot = await document.GetSyntaxRootAsync(context.CancellationToken) .ConfigureAwait(false); foreach (var diagnostic in context.Diagnostics) { if (syntaxRoot.TryFindNodeOrAncestor(diagnostic, out InvocationExpressionSyntax? invocation) && diagnostic.Properties.TryGetValue(nameof(DependencyPropertyKeyType), out var keyName)) { context.RegisterCodeFix( invocation.ToString(), (e, _) => e.ReplaceNode(invocation.Expression, x => SetValue(x)) .ReplaceNode(invocation.ArgumentList.Arguments[0].Expression, x => PropertyKey(x)), this.GetType().FullName, diagnostic); ExpressionSyntax PropertyKey(ExpressionSyntax old) { return(old switch { IdentifierNameSyntax id => id.WithIdentifier(SyntaxFactory.Identifier(keyName)), MemberAccessExpressionSyntax { Name : IdentifierNameSyntax id } ma => ma.WithName(id.WithIdentifier(SyntaxFactory.Identifier(keyName))), _ => old, }); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { return(node.Identifier.Text switch { "FilePath" => node.WithIdentifier(SyntaxFactory.Identifier("AbsolutePath")), "DirectoryPath" => node.WithIdentifier(SyntaxFactory.Identifier("AbsolutePath")), _ => node });
static ExpressionSyntax SetValue(ExpressionSyntax old) { return(old switch { IdentifierNameSyntax id => id.WithIdentifier(SyntaxFactory.Identifier("SetValue")), MemberAccessExpressionSyntax { Name : IdentifierNameSyntax id } ma => ma.WithName(id.WithIdentifier(SyntaxFactory.Identifier("SetValue"))), _ => old, });
/// <summary> /// Converts <paramref name="name" /> to a synthesized name. /// </summary> /// <param name="name">The name that should be converted.</param> public static IdentifierNameSyntax ToSynthesized(this IdentifierNameSyntax name) { Requires.NotNull(name, nameof(name)); Requires.That(!IsSynthesized(name), nameof(name), "The name has already been escaped."); return(name.WithIdentifier(name.Identifier.ToSynthesized())); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { // This method handles NameColonSyntax as well as regular references to parameter // Considers: // foo(a: 1); -> foo(b: 1); // int c = a; -> int c = b; // Get related symbol CommonSymbolInfo symbolInfo = this.model.GetSymbolInfo(node, this.cancellationToken); ISymbol referencedSymbol = symbolInfo.Symbol; if (referencedSymbol != null) { // Verify does the name refer to searched symbol if (referencedSymbol.Equals(this.parameterSymbol)) { // Rename the identifier token SyntaxToken identifierToken = node.Identifier; return(node.WithIdentifier(Syntax.Identifier(identifierToken.LeadingTrivia, this.newName, identifierToken.TrailingTrivia))); } } // Perform default behavior return(base.VisitIdentifierName(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (node.Identifier.Text == "DBNull") { return(node.WithIdentifier(SyntaxFactory.Identifier("CKFixDBNull"))); } return(node); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (TryGetRenamedVariable(node.Identifier.ValueText, out var newName)) { return(node.WithIdentifier(SyntaxFactory.Identifier(newName))); } return(base.VisitIdentifierName(node)); }
protected virtual SyntaxNode Rename(IdentifierNameSyntax node) { SyntaxToken newIdentifier = SyntaxFactory.Identifier( node.Identifier.LeadingTrivia, NewName, node.Identifier.TrailingTrivia); return(node.WithIdentifier(newIdentifier)); }
public override SyntaxNode Visit(SyntaxNode node) { if (node != null) { if (node is FieldDeclarationSyntax) { FieldDeclarationSyntax declarationSyntax = (FieldDeclarationSyntax)node; if (declarationSyntax.Declaration.Type is IdentifierNameSyntax) { IdentifierNameSyntax id = (IdentifierNameSyntax)declarationSyntax.Declaration.Type; String name = id.Identifier.ValueText; if (!SharedContainer.Instance.nameType.ContainsKey(name)) { return(node); } } } if (node is ParameterSyntax) { ParameterSyntax parameterSyntax = (ParameterSyntax)node; if (parameterSyntax.Type is IdentifierNameSyntax) { IdentifierNameSyntax id = (IdentifierNameSyntax)parameterSyntax.Type; String name = id.Identifier.ValueText; if (!SharedContainer.Instance.nameType.ContainsKey(name)) { return(node); } } } if (node is IdentifierNameSyntax) { IdentifierNameSyntax oldNode = (IdentifierNameSyntax)node; string name = oldNode.Identifier.ValueText; if (SharedContainer.Instance.nameMap.ContainsKey(name)) { IdentifierNameSyntax newNode = oldNode.WithIdentifier(Identifier(SharedContainer.Instance.nameMap[name])).WithLeadingTrivia(oldNode.GetLeadingTrivia()).WithTrailingTrivia(oldNode.GetTrailingTrivia()); return(node.ReplaceNode(oldNode, newNode)); } } if (node is ForEachStatementSyntax) { ForEachStatementSyntax oldNode = (ForEachStatementSyntax)node; string name = oldNode.Identifier.ValueText; if (SharedContainer.Instance.nameMap.ContainsKey(name)) { ForEachStatementSyntax newNode = oldNode.WithIdentifier(Identifier(SharedContainer.Instance.nameMap[name] + " ")); return(base.Visit(node.ReplaceNode(oldNode, newNode))); } } return(base.Visit(node)); } return(base.Visit(node)); }
static ISet <SyntaxTree> getMutationsForNode(SyntaxNode node, SyntaxNode rootNode, DataFlow optionalDataFlow = null) { ISet <SyntaxTree> toReturn = new HashSet <SyntaxTree>(); BinaryExpressionSyntax binaryExpression = node as BinaryExpressionSyntax; PostfixUnaryExpressionSyntax postfixUnaryExpression = node as PostfixUnaryExpressionSyntax; PrefixUnaryExpressionSyntax prefixUnaryExpression = node as PrefixUnaryExpressionSyntax; BlockSyntax block = node as BlockSyntax; StatementSyntax statement = node as StatementSyntax; IdentifierNameSyntax identifierName = node as IdentifierNameSyntax; if (binaryExpression != null) { ISet <SyntaxToken> validMutations = validBinaryOperatorMutations(binaryExpression); foreach (SyntaxToken mutatedToken in validMutations) { SyntaxNode newRoot = rootNode.ReplaceNode(node, binaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias)); toReturn.Add(newRoot.SyntaxTree); } } else if (postfixUnaryExpression != null) { ISet <SyntaxToken> validMutations = validUnaryOperatorMutations(postfixUnaryExpression); foreach (SyntaxToken mutatedToken in validMutations) { SyntaxNode newRoot = rootNode.ReplaceNode(node, postfixUnaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias)); toReturn.Add(newRoot.SyntaxTree); } } else if (prefixUnaryExpression != null) { ISet <SyntaxToken> validMutations = validUnaryOperatorMutations(prefixUnaryExpression); foreach (SyntaxToken mutatedToken in validMutations) { SyntaxNode newRoot = rootNode.ReplaceNode(node, prefixUnaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias)); toReturn.Add(newRoot.SyntaxTree); } } else if (statement != null && block == null) { //replace statements with semicolons toReturn.Add(rootNode.ReplaceNode(node, SyntaxFactory.EmptyStatement(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithTrailingTrivia(syntaxTrivias)).SyntaxTree); } else if (identifierName != null && optionalDataFlow != null) { //Go through reaching definitions and replace with all other variables available ISet <SyntaxToken> validMutations = validIdentifierNames(identifierName, optionalDataFlow); foreach (SyntaxToken mutatedToken in validMutations) { SyntaxNode newRoot = rootNode.ReplaceNode(node, identifierName.WithIdentifier(mutatedToken).WithTrailingTrivia(syntaxTrivias)); toReturn.Add(newRoot.SyntaxTree); } } return(toReturn); }
/// <inheritdoc/> public override async Task RegisterCodeFixesAsync(CodeFixContext context) { var document = context.Document; var root = await document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); foreach (var diagnostic in context.Diagnostics) { var token = root.FindToken(diagnostic.Location.SourceSpan.Start); var newName = char.ToUpper(token.ValueText[0]) + token.ValueText.Substring(1); var memberSyntax = this.GetParentTypeDeclaration(token); if (memberSyntax is NamespaceDeclarationSyntax) { // namespaces are not symbols. So we are just renaming the namespace Func <CancellationToken, Task <Document> > renameNamespace = cancellationToken => { IdentifierNameSyntax identifierSyntax = (IdentifierNameSyntax)token.Parent; var newIdentifierSyntac = identifierSyntax.WithIdentifier(SyntaxFactory.Identifier(newName)); var newRoot = root.ReplaceNode(identifierSyntax, newIdentifierSyntac); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }; context.RegisterCodeFix( CodeAction.Create( string.Format(NamingResources.RenameToCodeFix, newName), renameNamespace, nameof(RenameToUpperCaseCodeFixProvider) + "_" + diagnostic.Id), diagnostic); } else if (memberSyntax != null) { SemanticModel semanticModel = await document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); var typeDeclarationSymbol = semanticModel.GetDeclaredSymbol(memberSyntax); if (typeDeclarationSymbol == null) { continue; } if (!this.IsValidNewMemberName(typeDeclarationSymbol, newName)) { newName = newName + Suffix; } context.RegisterCodeFix( CodeAction.Create( string.Format(NamingResources.RenameToCodeFix, newName), cancellationToken => RenameHelper.RenameSymbolAsync(document, root, token, newName, cancellationToken), nameof(RenameToUpperCaseCodeFixProvider) + "_" + diagnostic.Id), diagnostic); } } }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (IdentifierNames.Contains(node)) { return(node .WithIdentifier(NewIdentifier) .WithTriviaFrom(node)); } return(base.VisitIdentifierName(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var id = node.Identifier.ValueText; if (!identities.ContainsKey(id) || identities[id] < 2) { return(base.VisitIdentifierName(node)); } return(base.VisitIdentifierName(node.WithIdentifier(Identifier(id)))); }
private static async Task <Document> ReplaceDeltaTimeIdentifierAsync(Document document, IdentifierNameSyntax identifierName, string name, CancellationToken ct) { var root = await document .GetSyntaxRootAsync(ct) .ConfigureAwait(false); var newIdentifierName = identifierName.WithIdentifier(SyntaxFactory.Identifier(name)); var newRoot = root.ReplaceNode(identifierName, newIdentifierName); return(document.WithSyntaxRoot(newRoot)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { IdentifierNameSyntax processedNode = (IdentifierNameSyntax)base.VisitIdentifierName(node); ISymbol symbol = this.model.GetSymbolInfo(node, this.cancellationToken).Symbol; // If this is reference to renamed symbol, replace identifier if (this.renamedSymbol.Equals(symbol)) { SyntaxToken identifier = node.Identifier; SyntaxToken newIdentifier = Syntax.Identifier(identifier.LeadingTrivia, this.newName, identifier.TrailingTrivia); IdentifierNameSyntax newIdentifierName = processedNode.WithIdentifier(newIdentifier); return newIdentifierName; } else if (node.Identifier.ValueText == this.newName) { // If the Identifier refers to type name within variable declaration, no action is undertaken // Consider: // newVariableName myVariable; -> type name can remain as is if (node.Ancestors().OfType<VariableDeclarationSyntax>().Any(n => n.Type.DescendantNodesAndSelf().Contains(node))) { return processedNode; } // If it is not a top-most expression of MemberAccessExpression, don't qualify if (node.Ancestors().OfType<MemberAccessExpressionSyntax>().Any(n => n.Name.DescendantNodesAndSelf().Contains(node))) { return processedNode; } ExpressionSyntax qualifier = null; if (symbol.IsStatic) { // If symbol is static, qualify the reference with containing type's name qualifier = Syntax.ParseTypeName(symbol.ContainingType.ToMinimalDisplayString(node.GetLocation(), this.model)); } else { // If symbol is instance, qualify the reference with `this' keyword qualifier = Syntax.ThisExpression(); } MemberAccessExpressionSyntax memberAccess = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, qualifier, processedNode); return memberAccess; } return processedNode; }
private async Task <Document> ConvertToCSharpAlias(Document curDocument, IdentifierNameSyntax curIdentifier, CancellationToken cancellationToken) { var syntaxRoot = await curDocument.GetSyntaxRootAsync(cancellationToken); var typeAlias = typeAliases[curIdentifier.Identifier.ValueText]; var newIdentifier = curIdentifier.WithIdentifier(SyntaxFactory.Identifier(typeAlias)); var newSyntaxRoot = syntaxRoot.ReplaceNode(curIdentifier, newIdentifier); var newDocument = curDocument.WithSyntaxRoot(newSyntaxRoot); return(newDocument); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var identifier = node.Identifier; if (node.Identifier.ValueText.Contains("Paradox")) { var newName = node.Identifier.ValueText.Replace("Paradox", "Xenko"); return(node.WithIdentifier(SyntaxFactory.Identifier(identifier.LeadingTrivia, newName, identifier.TrailingTrivia))); } return(base.VisitIdentifierName(node)); }
private async Task <Document> ReplaceDateTimeWithDateTimeOffsetAsync(Document document, SyntaxNode node, CancellationToken cancellationToken) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); IdentifierNameSyntax convertedNode = (IdentifierNameSyntax)node; IdentifierNameSyntax?newNode = convertedNode?.WithIdentifier(SyntaxFactory.ParseToken("DateTimeOffset")).WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia()); SyntaxNode newRoot = root.ReplaceNode(node, newNode); Document newDocument = document.WithSyntaxRoot(newRoot); return(newDocument); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var symbol = model.GetSymbolInfo(node).Symbol; if (symbol != null) { string newName = rename(symbol); if (newName != null) { return(node.WithIdentifier(node.Identifier.CopyAnnotationsTo(SyntaxFactory.Identifier(newName)))); } } return(base.VisitIdentifierName(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { node = (IdentifierNameSyntax)base.VisitIdentifierName(node); if (_context.GetNodeType(node) == _type) { node = node.WithIdentifier(SyntaxFactory.Identifier(_newType) .WithTrailingTrivia(node.Identifier.TrailingTrivia) .WithLeadingTrivia(node.Identifier.LeadingTrivia)); node = node.CopyAnnotationsTo(node); } return(node); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { node = (IdentifierNameSyntax)base.VisitIdentifierName(node); if (String.Equals(node.Identifier.Text, originalName)) { SyntaxToken replacement = SyntaxFactory.Identifier( node.Identifier.LeadingTrivia, newName, node.Identifier.TrailingTrivia); node = node.WithIdentifier(replacement); } return(node); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { node = (IdentifierNameSyntax)base.VisitIdentifierName(node); ExpressionSyntax newNameString; if (Rename(AttributeMatchUtil.TriviaAnnotationToAttributesList(node.GetLeadingTrivia()), out newNameString)) { string newName = ((LiteralExpressionSyntax)newNameString).Token.Text; if (newName.StartsWith("\"") && newName.EndsWith("\"")) { newName = newName.Substring(1, newName.Length - 2); } node = node.WithIdentifier(SyntaxFactory.Identifier(newName)); } return(node); }
// // Primary wideners // private static TypeSyntax WidenType(TypeSyntax type) { switch (type.Kind()) { default: throw new ArgumentException(); case SyntaxKind.PredefinedType: if (((PredefinedTypeSyntax)type).Keyword.Kind() == SyntaxKind.IntKeyword) { type = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.LongKeyword)).WithTrailingTrivia(SyntaxFactory.Space); } else if (((PredefinedTypeSyntax)type).Keyword.Kind() == SyntaxKind.UIntKeyword) { type = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ULongKeyword)).WithTrailingTrivia(SyntaxFactory.Space); } else { throw new ArgumentException(); } break; case SyntaxKind.GenericName: GenericNameSyntax genericType = (GenericNameSyntax)type; type = genericType.WithIdentifier( SyntaxFactory.Identifier(genericType.Identifier.Text + LongAppendText) .WithTriviaFrom(genericType.Identifier)); break; case SyntaxKind.IdentifierName: IdentifierNameSyntax identifierType = (IdentifierNameSyntax)type; type = identifierType.WithIdentifier( SyntaxFactory.Identifier(identifierType.Identifier.Text + LongAppendText) .WithTriviaFrom(identifierType.Identifier)); break; case SyntaxKind.ArrayType: ArrayTypeSyntax arrayType = (ArrayTypeSyntax)type; type = arrayType.WithElementType(WidenType(arrayType.ElementType)); break; } return(type); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { ISymbol identifierSymbol = semanticModel.GetSymbolInfo(node).Symbol; if (identifierSymbol != null) { ISymbol subst; if (replace.TryGetValue(identifierSymbol, out subst)) { return(node.WithIdentifier( SyntaxFactory.Identifier( node.Identifier.LeadingTrivia, subst.Name, node.Identifier.TrailingTrivia))); } } return(base.VisitIdentifierName(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax name) { // TODO: Hanlde initializer list correctly var symbolInfo = _semanticModel.GetSymbolInfo(name); var fieldSymbol = symbolInfo.Symbol as IFieldSymbol; if (fieldSymbol != null && fieldSymbol.DeclaredAccessibility == Accessibility.Private && !fieldSymbol.IsConst && !fieldSymbol.IsStatic) { name = name .WithIdentifier(SyntaxFactory.Identifier(GetChangedName(name.Identifier.ValueText))) .WithLeadingTrivia(name.GetLeadingTrivia()) .WithTrailingTrivia(name.GetTrailingTrivia()); } return(name); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { SyntaxToken identifier = node.Identifier; if (string.Equals(identifier.ValueText, _name, StringComparison.Ordinal)) { ISymbol symbol = SemanticModel.GetSymbol(node, CancellationToken); if (Symbol.Equals(symbol)) { SyntaxToken newIdentifier = SyntaxFactory.Identifier( identifier.LeadingTrivia, NewName, identifier.TrailingTrivia); return(node.WithIdentifier(newIdentifier)); } } return(base.VisitIdentifierName(node)); }
private async Task <Document> ReplaceDateTimeAsync(Document document, IdentifierNameSyntax oldIdentifier, CancellationToken cancellationToken) { // Get the root syntax node for the current document var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); // Create a new syntax node var newIdentifier = oldIdentifier.WithIdentifier( SyntaxFactory.ParseToken(nameof(DateTimeOffset)) .WithLeadingTrivia(oldIdentifier.GetLeadingTrivia()) .WithTrailingTrivia(oldIdentifier.GetTrailingTrivia())); // Create a new root syntax node for the current document replacing // the syntax node that has diagnostic with a new syntax node var newRoot = root.ReplaceNode(oldIdentifier, newIdentifier); // Generate a new document var newDocument = document.WithSyntaxRoot(newRoot); return(newDocument); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (MainDataType == DataType.Float) { return(base.VisitIdentifierName(node)); } if (node.ToString() != mainDataTypeName) { return(base.VisitIdentifierName(node)); } if (TargetDataType == DataType.Double) { var newNode = SyntaxFactory.PredefinedType(SyntaxFactory.ParseToken("double")); return(newNode.WithTriviaFrom(node)); } else { var newNode = node.WithIdentifier(SyntaxFactory.Identifier(targetDataTypeName)); return(newNode.WithTriviaFrom(node)); } }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax name) { if (backingField != null) { if (name.Identifier.ValueText.Equals(backingField.Name)) { var symbolInfo = semanticModel.GetSymbolInfo(name); // Check binding info if (symbolInfo.Symbol != null && symbolInfo.Symbol.OriginalDefinition == backingField) { name = name.WithIdentifier( Syntax.Identifier(property.Identifier.ValueText)); return(CodeAnnotations.Formatting.AddAnnotationTo(name)); } } } return(name); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax name) { if (backingField != null) { if (name.Identifier.ValueText.Equals(backingField.Name)) { SymbolInfo symbolInfo = semanticModel.GetSymbolInfo(name); // Check binding info if (symbolInfo.Symbol != null && Equals(symbolInfo.Symbol.OriginalDefinition, backingField)) { name = name.WithIdentifier( SyntaxFactory.Identifier(property.Identifier.ValueText)); return(name.WithAdditionalAnnotations(Formatter.Annotation)); } } } return(name); }