private static Task <Document> UseStringEmptyInsteadOfEmptyStringLiteralAsync( Document document, ExpressionSyntax expression, CancellationToken cancellationToken = default) { MemberAccessExpressionSyntax memberAccessExpression = CSharpFactory.SimpleMemberAccessExpression( CSharpTypeFactory.StringType(), SyntaxFactory.IdentifierName("Empty")); memberAccessExpression = memberAccessExpression.WithTriviaFrom(expression); return(document.ReplaceNodeAsync(expression, memberAccessExpression, cancellationToken)); }
public static async Task <Document> RefactorAsync( Document document, ObjectCreationExpressionSyntax objectCreationExpression, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); TypeSyntax type = semanticModel .GetTypeByMetadataName(MetadataNames.System_EventArgs) .ToMinimalTypeSyntax(semanticModel, objectCreationExpression.SpanStart); MemberAccessExpressionSyntax newNode = CSharpFactory.SimpleMemberAccessExpression(type, SyntaxFactory.IdentifierName("Empty")) .WithTriviaFrom(objectCreationExpression); return(await document.ReplaceNodeAsync(objectCreationExpression, newNode, cancellationToken).ConfigureAwait(false)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (_enumTypeSymbol != null && !node.IsParentKind(SyntaxKind.SimpleMemberAccessExpression)) { MemberAccessExpressionSyntax newNode = CSharpFactory.SimpleMemberAccessExpression( SyntaxFactory.ParseExpression(_enumTypeSymbol.ToDisplayString(SymbolDisplayFormats.TypeNameAndContainingTypesAndNamespaces)), node); if (!Options.FullyQualifiedNames) { newNode = newNode.WithAdditionalAnnotations(_simplifierAnnotationAsArray); } return(newNode); } return(base.VisitIdentifierName(node)); }
private Dictionary <SyntaxNode, object> GetReplacementMap(SyntaxNode node, Dictionary <ISymbol, string> symbolMap) { var replacementMap = new Dictionary <SyntaxNode, object>(); foreach (SyntaxNode descendant in node.DescendantNodesAndSelf(node.Span)) { SyntaxKind kind = descendant.Kind(); if (kind == SyntaxKind.IdentifierName) { var identifierName = (IdentifierNameSyntax)descendant; ISymbol symbol = DeclarationSemanticModel.GetSymbol(identifierName, CancellationToken); if (symbol != null) { if (symbol.IsParameter()) { foreach (ParameterInfo parameterInfo in ParameterInfos) { if (parameterInfo.ParameterSymbol.OriginalDefinition.Equals(symbol)) { replacementMap.Add(identifierName, parameterInfo.Expression); break; } } } else if (symbol.IsTypeParameter()) { var typeParameter = (ITypeParameterSymbol)symbol; ImmutableArray <ITypeSymbol> typeArguments = MethodSymbol.TypeArguments; if (typeArguments.Length > typeParameter.Ordinal) { replacementMap.Add(identifierName, typeArguments[typeParameter.Ordinal].ToMinimalTypeSyntax(DeclarationSemanticModel, identifierName.SpanStart)); } } else if (symbol.IsStatic && !identifierName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression)) { INamedTypeSymbol containingType = symbol.ContainingType; if (!InvocationEnclosingType .BaseTypesAndSelf() .Any(f => f.Equals(containingType))) { replacementMap.Add(identifierName, CSharpFactory.SimpleMemberAccessExpression(containingType.ToTypeSyntax().WithSimplifierAnnotation(), identifierName)); } } if (symbolMap != null && symbolMap.TryGetValue(symbol, out string name)) { replacementMap.Add(identifierName, SyntaxFactory.IdentifierName(name)); } } } else if (symbolMap != null) { if (kind.Is( SyntaxKind.VariableDeclarator, SyntaxKind.SingleVariableDesignation, SyntaxKind.Parameter, SyntaxKind.TypeParameter, SyntaxKind.ForEachStatement, SyntaxKind.ForEachVariableStatement)) { ISymbol symbol = DeclarationSemanticModel.GetDeclaredSymbol(descendant, CancellationToken); Debug.Assert(symbol != null || (descendant as ForEachVariableStatementSyntax)?.Variable?.Kind() == SyntaxKind.TupleExpression, kind.ToString()); if (symbol != null && symbolMap.TryGetValue(symbol, out string name)) { replacementMap.Add(descendant, name); } } } } return(replacementMap); }
public TNode RewriteNode <TNode>(TNode node) where TNode : SyntaxNode { Dictionary <ISymbol, string> symbolMap = GetSymbolsToRename(); var replacementMap = new Dictionary <SyntaxNode, object>(); foreach (SyntaxNode descendant in node.DescendantNodes(node.Span)) { SyntaxKind kind = descendant.Kind(); if (kind == SyntaxKind.IdentifierName) { var identifierName = (IdentifierNameSyntax)descendant; ISymbol symbol = DeclarationSemanticModel.GetSymbol(identifierName, CancellationToken); if (symbol != null) { if (symbol.IsParameter()) { foreach (ParameterInfo parameterInfo in ParameterInfos) { if (parameterInfo.ParameterSymbol.OriginalDefinition.Equals(symbol)) { replacementMap.Add(identifierName, parameterInfo.Expression); break; } } } else if (symbol.IsStatic && !identifierName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression)) { INamedTypeSymbol containingType = symbol.ContainingType; if (!InvocationEnclosingType .BaseTypesAndSelf() .Any(f => f.Equals(containingType))) { replacementMap.Add(identifierName, CSharpFactory.SimpleMemberAccessExpression(containingType.ToTypeSyntax().WithSimplifierAnnotation(), identifierName)); } } if (symbolMap != null) { string name; if (symbolMap.TryGetValue(symbol, out name)) { replacementMap.Add(identifierName, SyntaxFactory.IdentifierName(name)); } } } } else if (symbolMap != null && kind == SyntaxKind.VariableDeclarator) { var variableDeclarator = (VariableDeclaratorSyntax)descendant; ISymbol symbol = DeclarationSemanticModel.GetDeclaredSymbol(variableDeclarator, CancellationToken); string name; if (symbolMap.TryGetValue(symbol, out name)) { replacementMap.Add(variableDeclarator, name); } } } var rewriter = new InlineMethodRewriter(replacementMap); return((TNode)rewriter.Visit(node)); }
private Dictionary <SyntaxNode, object> GetReplacementMap(SyntaxNode node, Dictionary <ISymbol, string> symbolMap) { var replacementMap = new Dictionary <SyntaxNode, object>(); foreach (SyntaxNode descendant in node.DescendantNodesAndSelf(node.Span)) { SyntaxKind kind = descendant.Kind(); if (kind == SyntaxKind.IdentifierName) { var identifierName = (IdentifierNameSyntax)descendant; ISymbol symbol = DeclarationSemanticModel.GetSymbol(identifierName, CancellationToken); if (symbol != null) { if (symbol is IParameterSymbol parameterSymbol) { foreach (ParameterInfo parameterInfo in ParameterInfos) { if (ParameterEquals(parameterInfo, parameterSymbol)) { ExpressionSyntax expression = parameterInfo.Expression; if (expression == null && parameterInfo.ParameterSymbol.HasExplicitDefaultValue) { expression = parameterInfo.ParameterSymbol.GetDefaultValueMinimalSyntax(InvocationSemanticModel, Node.SpanStart); } replacementMap.Add(identifierName, expression); break; } } } else if (symbol.Kind == SymbolKind.TypeParameter) { var typeParameter = (ITypeParameterSymbol)symbol; ImmutableArray <ITypeSymbol> typeArguments = TypeArguments; if (typeArguments.Length > typeParameter.Ordinal) { replacementMap.Add(identifierName, typeArguments[typeParameter.Ordinal].ToMinimalTypeSyntax(DeclarationSemanticModel, identifierName.SpanStart)); } } else if (symbol.IsStatic && !identifierName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression, SyntaxKind.QualifiedName)) { INamedTypeSymbol containingType = symbol.ContainingType; if (containingType != null) { if (!NodeEnclosingType .BaseTypesAndSelf() .Any(f => f.Equals(containingType))) { replacementMap.Add(identifierName, CSharpFactory.SimpleMemberAccessExpression(containingType.ToTypeSyntax().WithSimplifierAnnotation(), identifierName)); } } else if (symbol is ITypeSymbol typeSymbol) { replacementMap.Add(identifierName, typeSymbol.ToMinimalTypeSyntax(InvocationSemanticModel, Node.SpanStart)); } } if (symbolMap != null && symbolMap.TryGetValue(symbol, out string name)) { replacementMap.Add(identifierName, IdentifierName(name)); } } } else if (symbolMap != null) { if (kind.Is( SyntaxKind.VariableDeclarator, SyntaxKind.SingleVariableDesignation, SyntaxKind.Parameter, SyntaxKind.TypeParameter, SyntaxKind.ForEachStatement, SyntaxKind.ForEachVariableStatement)) { ISymbol symbol = DeclarationSemanticModel.GetDeclaredSymbol(descendant, CancellationToken); Debug.Assert(symbol != null || (descendant as ForEachVariableStatementSyntax)?.Variable?.Kind() == SyntaxKind.TupleExpression, kind.ToString()); if (symbol != null && symbolMap.TryGetValue(symbol, out string name)) { replacementMap.Add(descendant, name); } } } } return(replacementMap); bool ParameterEquals(in ParameterInfo parameterInfo, IParameterSymbol parameterSymbol2) { IParameterSymbol parameterSymbol = parameterInfo.ParameterSymbol; if (parameterSymbol.ContainingSymbol is IMethodSymbol methodSymbol) { if (parameterInfo.IsThis || methodSymbol.MethodKind == MethodKind.ReducedExtension) { int ordinal = parameterSymbol.Ordinal; if (methodSymbol.MethodKind == MethodKind.ReducedExtension) { ordinal++; } return(ordinal == parameterSymbol2.Ordinal && string.Equals(parameterSymbol.Name, parameterSymbol2.Name, StringComparison.Ordinal)); } } return(parameterSymbol.OriginalDefinition.Equals(parameterSymbol2)); } }