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