public static async Task <Document> RefactorAsync( Document document, ExpressionSyntax expression, IMethodSymbol methodSymbol, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); InvocationExpressionSyntax invocation = InvocationExpression(expression.WithoutTrailingTrivia(), IdentifierName(methodSymbol.Name)) .WithTrailingTrivia(expression.GetTrailingTrivia()); SyntaxNode newRoot = root.ReplaceNode(expression, invocation); SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); if (methodSymbol.IsExtensionMethod) { INamespaceSymbol namespaceSymbol = methodSymbol.ContainingNamespace; if (namespaceSymbol != null && !SyntaxUtility.IsUsingDirectiveInScope(expression, namespaceSymbol, semanticModel, cancellationToken) && newRoot.IsKind(SyntaxKind.CompilationUnit)) { newRoot = ((CompilationUnitSyntax)newRoot) .AddUsings(UsingDirective(ParseName(namespaceSymbol.ToString()))); } } return(document.WithSyntaxRoot(newRoot)); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, MemberAccessExpressionSyntax memberAccess) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddUsingStaticDirective) && memberAccess.Expression?.IsMissing == false && memberAccess.Name?.IsMissing == false && context.SupportsSemanticModel) { memberAccess = GetTopmostMemberAccessExpression(memberAccess); if (context.Span.IsBetweenSpans(memberAccess.Expression)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); var typeSymbol = semanticModel .GetSymbolInfo(memberAccess.Expression, context.CancellationToken) .Symbol as INamedTypeSymbol; if (typeSymbol?.IsStaticClass() == true && (typeSymbol.IsPublic() || typeSymbol.IsInternal()) && !SyntaxUtility.IsUsingStaticDirectiveInScope(memberAccess, typeSymbol, semanticModel, context.CancellationToken)) { context.RegisterRefactoring($"using static {typeSymbol.ToString()};", cancellationToken => { return(RefactorAsync( context.Document, typeSymbol.ToString(), memberAccess, cancellationToken)); }); } } } }
private static ConditionalExpressionSyntax CreateMultilineConditionalExpression(ConditionalExpressionSyntax conditionalExpression) { SyntaxTriviaList triviaList = SyntaxUtility.GetIndentTrivia(conditionalExpression.Parent).Add(CSharpFactory.IndentTrivia()); triviaList = triviaList.Insert(0, CSharpFactory.NewLineTrivia()); ParenthesizedExpressionSyntax condition = null; if (conditionalExpression.Condition.IsKind(SyntaxKind.ParenthesizedExpression)) { condition = (ParenthesizedExpressionSyntax)conditionalExpression.Condition; } else { condition = ParenthesizedExpression(conditionalExpression.Condition.WithoutTrailingTrivia()) .WithCloseParenToken(CreateTokenWithTrailingNewLine(SyntaxKind.CloseParenToken)); } return(ConditionalExpression( condition.WithoutTrailingTrivia(), conditionalExpression.WhenTrue.WithoutTrailingTrivia(), conditionalExpression.WhenFalse.WithoutTrailingTrivia()) .WithQuestionToken(CreateToken(SyntaxKind.QuestionToken, triviaList)) .WithColonToken(CreateToken(SyntaxKind.ColonToken, triviaList))); }
internal static async Task RenameIdentifierAccordingToTypeNameAsync( RefactoringContext context, ForEachStatementSyntax forEachStatement) { if (forEachStatement.Type != null && forEachStatement.Identifier.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); string oldName = forEachStatement.Identifier.ValueText; ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(forEachStatement.Type, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string newName = SyntaxUtility.CreateIdentifier( typeSymbol, firstCharToLower: true); if (!string.IsNullOrEmpty(newName) && !string.Equals(newName, oldName, StringComparison.Ordinal)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(forEachStatement, context.CancellationToken); context.RegisterRefactoring( $"Rename variable to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken)); } } } }
private static IfRefactoring CreateIfToAssignmentWithWithCoalesceExpression( IfStatementSyntax ifStatement, ExpressionSyntax left, ExpressionSyntax expression1, ExpressionSyntax expression2, NullCheckExpression nullCheck, SemanticModel semanticModel, CancellationToken cancellationToken) { if (nullCheck.Kind == NullCheckKind.EqualsToNull || nullCheck.Kind == NullCheckKind.NotEqualsToNull) { if (SyntaxComparer.AreEquivalent(nullCheck.Expression, expression1, requireNotNull: true)) { return(new IfElseToAssignmentWithCoalesceExpression(ifStatement, left, expression1, expression2)); } } if (expression1.IsKind(SyntaxKind.SimpleMemberAccessExpression) && SyntaxUtility.IsPropertyOfNullableOfT(expression1, "Value", semanticModel, cancellationToken)) { expression1 = ((MemberAccessExpressionSyntax)expression1).Expression; if (SyntaxComparer.AreEquivalent(nullCheck.Expression, expression1, requireNotNull: true)) { return(new IfElseToAssignmentWithCoalesceExpression(ifStatement, left, expression1, expression2)); } } return(null); }
private static InitializerExpressionSyntax GetMultilineInitializer(InitializerExpressionSyntax initializer) { SyntaxNode parent = initializer.Parent; if (parent.IsKind(SyntaxKind.ObjectCreationExpression) && !initializer.IsKind(SyntaxKind.CollectionInitializerExpression)) { return(initializer .WithExpressions( SeparatedList( initializer.Expressions.Select(expression => expression.WithLeadingTrivia(CSharpFactory.NewLineTrivia())))) .WithFormatterAnnotation()); } SyntaxTriviaList indent = SyntaxUtility.GetIndentTrivia(initializer); SyntaxTriviaList indent2 = indent.Add(CSharpFactory.IndentTrivia()); indent = indent.Insert(0, CSharpFactory.NewLineTrivia()); indent2 = indent2.Insert(0, CSharpFactory.NewLineTrivia()); return(initializer .WithExpressions( SeparatedList( initializer.Expressions.Select(expression => expression.WithLeadingTrivia(indent2)))) .WithOpenBraceToken(initializer.OpenBraceToken.WithLeadingTrivia(indent)) .WithCloseBraceToken(initializer.CloseBraceToken.WithLeadingTrivia(indent)) .WithFormatterAnnotation()); }
public static void ComputeRefactorings(RefactoringContext context, InterpolationSyntax interpolation) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeInterpolationIntoInterpolatedString) && MergeInterpolationIntoInterpolatedStringRefactoring.CanRefactor(interpolation)) { string innerText = SyntaxUtility.GetStringLiteralInnerText((LiteralExpressionSyntax)interpolation.Expression); context.RegisterRefactoring( $"Merge '{innerText}' into interpolated string", cancellationToken => MergeInterpolationIntoInterpolatedStringRefactoring.RefactorAsync(context.Document, interpolation, cancellationToken)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveInterpolation) && (interpolation.OpenBraceToken.Span.Contains(context.Span) || interpolation.CloseBraceToken.Span.Contains(context.Span))) { context.RegisterRefactoring("Remove interpolation", cancellationToken => { return(RemoveInterpolationRefactoring.RefactorAsync( context.Document, interpolation, cancellationToken)); }); } }
public static async Task ComputeRefactoringAsync(RefactoringContext context, ExpressionStatementSyntax expressionStatement) { if (context.SupportsSemanticModel) { var expression = expressionStatement.Expression as TypeSyntax; if (expression != null) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel .GetTypeInfo(expression, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string name = SyntaxUtility.CreateIdentifier(typeSymbol, firstCharToLower: true); if (!string.IsNullOrEmpty(name)) { context.RegisterRefactoring( $"Add identifier '{name}'", c => RefactorAsync(context.Document, expressionStatement, name, c)); } } } } }
private async Task <Document> RefactorAsync( Document document, MemberDeclarationSyntax member, CancellationToken cancellationToken = default(CancellationToken)) { if (member.IsParentKind(SyntaxKind.CompilationUnit)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string name = SyntaxUtility.GetUniqueName("Namespace", semanticModel, member.Span.Start); NamespaceDeclarationSyntax namespaceDeclaration = NamespaceDeclaration( IdentifierName(Identifier(name).WithRenameAnnotation()), default(SyntaxList <ExternAliasDirectiveSyntax>), default(SyntaxList <UsingDirectiveSyntax>), SingletonList(member)); SyntaxNode newRoot = root.ReplaceNode(member, namespaceDeclaration.WithFormatterAnnotation()); return(document.WithSyntaxRoot(newRoot)); } return(document); }
private static ExpressionSyntax GetNullableOfTValueProperty(ExpressionSyntax expression, SemanticModel semanticModel, CancellationToken cancellationToken) { if (expression.Kind() != SyntaxKind.SimpleMemberAccessExpression) { return(null); } var memberAccessExpression = (MemberAccessExpressionSyntax)expression; if (!(memberAccessExpression.Name is IdentifierNameSyntax identifierName)) { return(null); } if (!string.Equals(identifierName.Identifier.ValueText, "Value", StringComparison.Ordinal)) { return(null); } if (!SyntaxUtility.IsPropertyOfNullableOfT(expression, "Value", semanticModel, cancellationToken)) { return(null); } return(memberAccessExpression.Expression); }
public static void ParseEnumExpression <TEnum>( ExpressionSyntax argumentExpr, IDictionary <AttributeParamName, object> target, AttributeParamName key) where TEnum : Enum { var enumValue = SyntaxUtility.ParseEnumValue <TEnum>(argumentExpr); target[key] = enumValue; }
private static async Task <Document> IntroduceFieldToLockOnAsync( Document document, LockStatementSyntax lockStatement, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); MemberDeclarationSyntax containingMember = lockStatement.FirstAncestorOrSelf <MemberDeclarationSyntax>(); if (containingMember != null) { var containingDeclaration = (MemberDeclarationSyntax)containingMember .Ancestors() .FirstOrDefault(f => f.IsKind( SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration)); if (containingDeclaration != null) { SyntaxList <MemberDeclarationSyntax> members = containingDeclaration.GetMembers(); int index = members.IndexOf(containingMember); string name = LockObjectName; if (document.SupportsSemanticModel) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); name = SyntaxUtility.GetUniqueName(name, semanticModel, lockStatement.Expression.Span.Start); } LockStatementSyntax newLockStatement = lockStatement .WithExpression(IdentifierName(name)); MemberDeclarationSyntax newContainingMember = containingMember .ReplaceNode(lockStatement, newLockStatement); bool isStatic = containingMember.GetModifiers().Contains(SyntaxKind.StaticKeyword); FieldDeclarationSyntax field = CreateField(name, isStatic).WithFormatterAnnotation(); SyntaxList <MemberDeclarationSyntax> newMembers = members .Replace(members[index], newContainingMember) .Insert(FindField(members, index) + 1, field); MemberDeclarationSyntax newNode = containingDeclaration.SetMembers(newMembers); SyntaxNode newRoot = root.ReplaceNode(containingDeclaration, newNode); return(document.WithSyntaxRoot(newRoot)); } } return(document); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ParameterSyntax parameter) { if (!context.IsAnyRefactoringEnabled( RefactoringIdentifiers.AddParameterNameToParameter, RefactoringIdentifiers.RenameParameterAccordingToTypeName)) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); IParameterSymbol parameterSymbol = semanticModel.GetDeclaredSymbol(parameter, context.CancellationToken); if (parameterSymbol?.Type == null) { return; } if (parameter.Identifier.IsMissing) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddParameterNameToParameter)) { TextSpan span = (parameter.Type != null) ? TextSpan.FromBounds(parameter.Type.Span.End, parameter.Span.End) : parameter.Span; if (span.Contains(context.Span)) { string name = SyntaxUtility.CreateIdentifier(parameterSymbol.Type, firstCharToLower: true); if (!string.IsNullOrEmpty(name)) { context.RegisterRefactoring( $"Add parameter name '{name}'", cancellationToken => AddParameterNameToParameterAsync(context.Document, parameter, name, cancellationToken)); } } } } else if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameParameterAccordingToTypeName) && parameter.Identifier.Span.Contains(context.Span)) { string name = parameter.Identifier.ValueText; string newName = SyntaxUtility.CreateIdentifier(parameterSymbol.Type, firstCharToLower: true); if (!string.IsNullOrEmpty(newName) && !string.Equals(name, newName, StringComparison.Ordinal)) { ISymbol symbol = semanticModel.GetDeclaredSymbol(parameter, context.CancellationToken); context.RegisterRefactoring( $"Rename parameter to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken)); } } }
private static bool IsPropertyOfNullableOfT( ExpressionSyntax expression, string name, SemanticModel semanticModel, CancellationToken cancellationToken) { return(expression?.Kind() == SyntaxKind.IdentifierName && string.Equals(((IdentifierNameSyntax)expression).Identifier.ValueText, name, StringComparison.Ordinal) && SyntaxUtility.IsPropertyOfNullableOfT(expression, name, semanticModel, cancellationToken)); }
private static ExpressionSyntax AddParenthesesIfNecessary(SyntaxNode node, ExpressionSyntax expression) { if (!SyntaxUtility.AreParenthesesRedundantOrInvalid(node)) { expression = expression .WithoutTrivia() .Parenthesize(cutCopyTrivia: true); } return(expression); }
public static async Task <Document> RefactorAsync( Document document, PropertyDeclarationSyntax propertyDeclaration, bool prefixIdentifierWithUnderscore = true, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); string fieldName = TextUtility.ToCamelCase( propertyDeclaration.Identifier.ValueText, prefixWithUnderscore: prefixIdentifierWithUnderscore); FieldDeclarationSyntax fieldDeclaration = CreateBackingField(propertyDeclaration, fieldName) .WithFormatterAnnotation(); PropertyDeclarationSyntax newPropertyDeclaration = ExpandPropertyAndAddBackingField(propertyDeclaration, fieldName) .WithTriviaFrom(propertyDeclaration) .WithFormatterAnnotation(); var parentMember = (MemberDeclarationSyntax)propertyDeclaration.Parent; SyntaxList <MemberDeclarationSyntax> members = parentMember.GetMembers(); int propertyIndex = members.IndexOf(propertyDeclaration); if (propertyDeclaration.IsReadOnlyAutoProperty()) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync( semanticModel.GetDeclaredSymbol(propertyDeclaration, cancellationToken), document.Project.Solution, cancellationToken).ConfigureAwait(false); ImmutableArray <IdentifierNameSyntax> identifierNames = SyntaxUtility .FindNodes <IdentifierNameSyntax>(oldRoot, referencedSymbols) .ToImmutableArray(); var rewriter = new IdentifierNameSyntaxRewriter(identifierNames, Identifier(fieldName)); var newParentMember = (MemberDeclarationSyntax)rewriter.Visit(parentMember); members = newParentMember.GetMembers(); } int indexOfLastField = members.LastIndexOf(f => f.IsKind(SyntaxKind.FieldDeclaration)); SyntaxList <MemberDeclarationSyntax> newMembers = members .Replace(members[propertyIndex], newPropertyDeclaration) .Insert(indexOfLastField + 1, fieldDeclaration); SyntaxNode newRoot = oldRoot.ReplaceNode(parentMember, parentMember.SetMembers(newMembers)); return(document.WithSyntaxRoot(newRoot)); }
public static async Task <Document> RefactorAsync( Document document, ReturnStatementSyntax returnStatement, ITypeSymbol typeSymbol, ISymbol symbol, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); ExpressionSyntax expression = SyntaxUtility.CreateDefaultValue(typeSymbol); root = root.ReplaceNode( returnStatement, returnStatement.WithExpression(expression)); return(document.WithSyntaxRoot(root)); }
public static async Task ComputeRefactoringAsync(RefactoringContext context, LocalDeclarationStatementSyntax localDeclaration) { if (context.SupportsSemanticModel) { TypeSyntax type = localDeclaration.Declaration?.Type; if (type?.IsVar == false) { VariableDeclaratorSyntax declarator = localDeclaration.Declaration.Variables.FirstOrDefault(); if (declarator != null && context.Span.Start >= type.Span.Start) { SyntaxTriviaList triviaList = type.GetTrailingTrivia(); if (triviaList.Any()) { SyntaxTrivia trivia = triviaList .SkipWhile(f => f.IsKind(SyntaxKind.WhitespaceTrivia)) .FirstOrDefault(); if (trivia.IsKind(SyntaxKind.EndOfLineTrivia) && context.Span.End <= trivia.Span.Start) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(type, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string name = SyntaxUtility.CreateIdentifier(typeSymbol, firstCharToLower: true); if (!string.IsNullOrEmpty(name)) { context.RegisterRefactoring( $"Add identifier '{name}'", c => RefactorAsync(context.Document, declarator, type, name, c)); } } } } } } } }
public static bool CanRefactor(RefactoringContext context, ExpressionSyntax expression) { if (!SyntaxUtility.AreParenthesesRedundantOrInvalid(expression)) { try { Refactor(expression, context.Root); return(true); } catch (Exception ex) { Debug.WriteLine(ex.ToString()); Debug.Assert(false, $"{nameof(WrapExpressionInParenthesesRefactoring)}\r\n{expression.Kind().ToString()}"); } } return(false); }
private static IEnumerable <SyntaxNodeOrToken> CreateNodesAndTokens(ParameterListSyntax list) { SyntaxTriviaList trivia = SyntaxUtility.GetIndentTrivia(list.Parent).Add(CSharpFactory.IndentTrivia()); SeparatedSyntaxList <ParameterSyntax> .Enumerator en = list.Parameters.GetEnumerator(); if (en.MoveNext()) { yield return(en.Current.WithLeadingTrivia(trivia)); while (en.MoveNext()) { yield return(Token(SyntaxKind.CommaToken).WithTrailingNewLine()); yield return(en.Current.WithLeadingTrivia(trivia)); } } }
private static async Task RenameVariableAccordingToTypeNameAsync( RefactoringContext context, VariableDeclarationSyntax variableDeclaration) { if (variableDeclaration.Type != null && variableDeclaration.Parent?.IsKind(SyntaxKind.EventFieldDeclaration) == false && variableDeclaration.Variables.Count == 1 && variableDeclaration.Variables[0].Identifier.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); ISymbol symbol = semanticModel.GetDeclaredSymbol(variableDeclaration.Variables[0], context.CancellationToken); if (symbol != null) { ITypeSymbol typeSymbol = semanticModel.GetTypeInfo(variableDeclaration.Type, context.CancellationToken).Type; if (typeSymbol?.IsErrorType() == false) { string newName = SyntaxUtility.CreateIdentifier( typeSymbol, FirstCharToLower(symbol)); if (!string.IsNullOrEmpty(newName)) { if (context.Settings.PrefixFieldIdentifierWithUnderscore && symbol.IsField() && symbol.IsPrivate() && !((IFieldSymbol)symbol).IsConst) { newName = TextUtility.ToCamelCaseWithUnderscore(newName); } if (!string.Equals(variableDeclaration.Variables[0].Identifier.ValueText, newName, StringComparison.Ordinal)) { context.RegisterRefactoring( $"Rename {GetName(symbol)} to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, symbol, newName, cancellationToken)); } } } } } }
private static async Task <Document> FormatOnMultipleLinesAsync( Document document, BinaryExpressionSyntax condition, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxTriviaList triviaList = SyntaxFactory.TriviaList(CSharpFactory.NewLineTrivia()) .AddRange(SyntaxUtility.GetIndentTrivia(condition)) .Add(CSharpFactory.IndentTrivia()); var rewriter = new BinaryExpressioneSyntaxRewriter(triviaList); var newCondition = (ExpressionSyntax)rewriter.Visit(condition); root = root.ReplaceNode(condition, newCondition); return(document.WithSyntaxRoot(root)); }
private static bool IsPropertyOfNullableOfT(ExpressionSyntax expression, string name, SemanticModel semanticModel, CancellationToken cancellationToken) { if (expression?.Kind() == SyntaxKind.SimpleMemberAccessExpression) { var memberAccessExpression = (MemberAccessExpressionSyntax)expression; SimpleNameSyntax simpleName = memberAccessExpression.Name; if (simpleName?.Kind() == SyntaxKind.IdentifierName) { var identifierName = (IdentifierNameSyntax)simpleName; return(string.Equals(identifierName.Identifier.ValueText, name, StringComparison.Ordinal) && SyntaxUtility.IsPropertyOfNullableOfT(expression, name, semanticModel, cancellationToken)); } } return(false); }
private static async Task <ExpressionSyntax> ReplaceParameterExpressionWithArgumentExpressionAsync( ParameterInfo[] parameterInfos, InvocationExpressionSyntax invocation, ExpressionSyntax expression, Solution solution, CancellationToken cancellationToken) { ExpressionSyntax newExpression = await ReplaceParameterExpressionWithArgumentExpressionAsync(parameterInfos, expression, solution, cancellationToken).ConfigureAwait(false); if (!SyntaxUtility.AreParenthesesRedundantOrInvalid(invocation)) { newExpression = newExpression .WithoutTrivia() .Parenthesize(); } return(newExpression .WithTriviaFrom(invocation) .WithFormatterAnnotation()); }
private static VariableDeclaratorSyntax GetNewDeclarator( VariableDeclaratorSyntax declarator, TypeSyntax type, ITypeSymbol typeSymbol) { ExpressionSyntax value = SyntaxUtility.CreateDefaultValue(typeSymbol, type); EqualsValueClauseSyntax @default = EqualsValueClause(value); if (declarator.Initializer == null || declarator.Initializer.IsMissing) { return(declarator .WithIdentifier(declarator.Identifier.WithoutTrailingTrivia()) .WithInitializer(@default.WithTrailingTrivia(declarator.Identifier.TrailingTrivia))); } else { return(declarator .WithInitializer(@default.WithTriviaFrom(declarator.Initializer.EqualsToken))); } }
private static async Task <Document> FormatExpressionChainOnMultipleLinesAsync( Document document, ImmutableArray <MemberAccessExpressionSyntax> expressions, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); MemberAccessExpressionSyntax expression = expressions[0]; SyntaxTriviaList triviaList = SyntaxUtility.GetIndentTrivia(expression).Add(CSharpFactory.IndentTrivia()); triviaList = triviaList.Insert(0, CSharpFactory.NewLineTrivia()); var rewriter = new ExpressionChainSyntaxRewriter(expressions, triviaList); SyntaxNode newNode = rewriter.Visit(expression) .WithFormatterAnnotation(); SyntaxNode newRoot = oldRoot.ReplaceNode(expression, newNode); return(document.WithSyntaxRoot(newRoot)); }
public static async Task <Document> RefactorAsync( Document document, InterpolationSyntax interpolation, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var interpolatedString = (InterpolatedStringExpressionSyntax)interpolation.Parent; string s = interpolatedString.ToString(); s = s.Substring(0, interpolation.Span.Start - interpolatedString.Span.Start) + SyntaxUtility.GetStringLiteralInnerText((LiteralExpressionSyntax)interpolation.Expression) + s.Substring(interpolation.Span.End - interpolatedString.Span.Start); var newInterpolatedString = (InterpolatedStringExpressionSyntax)SyntaxFactory.ParseExpression(s) .WithTriviaFrom(interpolatedString); SyntaxNode newRoot = root.ReplaceNode(interpolatedString, newInterpolatedString); return(document.WithSyntaxRoot(newRoot)); }
private static ParameterSyntax GetNewParameter( ParameterSyntax parameter, ITypeSymbol typeSymbol) { ExpressionSyntax value = SyntaxUtility.CreateDefaultValue( typeSymbol, parameter.Type.WithoutTrivia()); EqualsValueClauseSyntax @default = EqualsValueClause(value); if (parameter.Default == null || parameter.IsMissing) { return(parameter .WithIdentifier(parameter.Identifier.WithoutTrailingTrivia()) .WithDefault(@default.WithTrailingTrivia(parameter.Identifier.TrailingTrivia))); } else { return(parameter .WithDefault(@default.WithTriviaFrom(parameter.Default.EqualsToken))); } }
private static async Task RenameMethodAccoringToTypeNameAsync( RefactoringContext context, MethodDeclarationSyntax methodDeclaration) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameMethodAccordingToTypeName) && context.SupportsSemanticModel && methodDeclaration.ReturnType?.IsVoid() == false && methodDeclaration.Identifier.Span.Contains(context.Span)) { SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken); ITypeSymbol typeSymbol = GetType(methodDeclaration.ReturnType, semanticModel, context.CancellationToken); if (typeSymbol != null) { string newName = SyntaxUtility.CreateIdentifier(typeSymbol); if (!string.IsNullOrEmpty(newName)) { newName = "Get" + newName; if (methodSymbol.IsAsync) { newName += "Async"; } if (!string.Equals(newName, methodDeclaration.Identifier.ValueText, StringComparison.Ordinal)) { context.RegisterRefactoring( $"Rename method to '{newName}'", cancellationToken => SymbolRenamer.RenameAsync(context.Document, methodSymbol, newName, cancellationToken)); } } } } }
private static IEnumerable <SyntaxNodeOrToken> CreateMultilineNodesAndTokens(AttributeArgumentListSyntax argumentList) { SyntaxTriviaList trivia = SyntaxUtility.GetIndentTrivia(argumentList.Parent).Add(CSharpFactory.IndentTrivia()); SeparatedSyntaxList <AttributeArgumentSyntax> .Enumerator en = argumentList.Arguments.GetEnumerator(); if (en.MoveNext()) { yield return(en.Current .TrimTrailingTrivia() .WithLeadingTrivia(trivia)); while (en.MoveNext()) { yield return(Token(SyntaxKind.CommaToken) .WithTrailingNewLine()); yield return(en.Current .TrimTrailingTrivia() .WithLeadingTrivia(trivia)); } } }