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 bool CanRefactor(InterpolationSyntax interpolation) { if (interpolation == null) { throw new ArgumentNullException(nameof(interpolation)); } ExpressionSyntax expression = interpolation.Expression; if (expression?.IsKind(SyntaxKind.StringLiteralExpression) == true) { var interpolatedString = interpolation.Parent as InterpolatedStringExpressionSyntax; if (interpolatedString != null) { var literalExpression = (LiteralExpressionSyntax)expression; if (interpolatedString.IsVerbatim() == literalExpression.Token.IsVerbatimStringLiteral()) { return(true); } } } return(false); }
public static Task <Document> RefactorAsync( Document document, InterpolationSyntax interpolation, CancellationToken cancellationToken = default(CancellationToken)) { if (document == null) { throw new ArgumentNullException(nameof(document)); } if (interpolation == null) { throw new ArgumentNullException(nameof(interpolation)); } var interpolatedString = (InterpolatedStringExpressionSyntax)interpolation.Parent; string s = interpolatedString.ToString(); var literalExpression = (LiteralExpressionSyntax)interpolation.Expression; s = s.Substring(0, interpolation.Span.Start - interpolatedString.Span.Start) + StringUtility.DoubleBraces(literalExpression.GetStringLiteralInnerText()) + s.Substring(interpolation.Span.End - interpolatedString.Span.Start); var newInterpolatedString = (InterpolatedStringExpressionSyntax)SyntaxFactory.ParseExpression(s) .WithTriviaFrom(interpolatedString); return(document.ReplaceNodeAsync(interpolatedString, newInterpolatedString, cancellationToken)); }
public static Doc Print(InterpolationSyntax node) { var docs = new List <Doc> { Token.Print(node.OpenBraceToken), Node.Print(node.Expression) }; if (node.AlignmentClause != null) { docs.Add( Token.PrintWithSuffix(node.AlignmentClause.CommaToken, " "), Node.Print(node.AlignmentClause.Value) ); } if (node.FormatClause != null) { docs.Add( Token.Print(node.FormatClause.ColonToken), Token.Print(node.FormatClause.FormatStringToken) ); } docs.Add(Token.Print(node.CloseBraceToken)); return(Doc.Concat(docs)); }
private Doc PrintInterpolationSyntax(InterpolationSyntax node) { var parts = new Parts( this.PrintSyntaxToken(node.OpenBraceToken), this.Print(node.Expression) ); if (node.AlignmentClause != null) { parts.Push( this.PrintSyntaxToken(node.AlignmentClause.CommaToken, " "), this.Print(node.AlignmentClause.Value) ); } if (node.FormatClause != null) { parts.Push( this.PrintSyntaxToken(node.FormatClause.ColonToken), this.PrintSyntaxToken(node.FormatClause.FormatStringToken) ); } parts.Push(this.PrintSyntaxToken(node.CloseBraceToken)); return(Concat(parts)); }
public override Evaluation VisitInterpolation(InterpolationSyntax node) { node.AlignmentClause?.Accept <Evaluation>(this); node.FormatClause?.Accept <Evaluation>(this); node.Expression?.Accept <Evaluation>(this); return(base.VisitInterpolation(node)); }
public override void VisitInterpolation(InterpolationSyntax node) { node.AlignmentClause?.Accept(this); node.FormatClause?.Accept(this); node.Expression?.Accept(this); base.VisitInterpolation(node); }
public static void ComputeRefactorings(RefactoringContext context, InterpolationSyntax interpolation) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveInterpolation) && context.Span.IsContainedInSpan(interpolation.OpenBraceToken, interpolation.CloseBraceToken)) { context.RegisterRefactoring("Remove interpolation", cancellationToken => context.Document.RemoveNodeAsync(interpolation, SyntaxRemoveOptions.KeepUnbalancedDirectives, cancellationToken)); } }
private static void InterpolationCheck(InterpolationSyntax interpolation, SemanticModel semanticModel, Action <Diagnostic> reportDiagnostic, string filePath, CancellationToken cancellationToken) { var typeInfo = semanticModel.GetTypeInfo(interpolation.Expression, cancellationToken); if (typeInfo.Type?.IsValueType == true) { reportDiagnostic(Diagnostic.Create(ValueTypeToReferenceTypeConversionRule, interpolation.Expression.GetLocation(), EmptyMessageArgs)); HeapAllocationAnalyzerEventSource.Logger.BoxingAllocation(filePath); } }
public override SyntaxNode VisitInterpolation(InterpolationSyntax node) { var result = (InterpolationSyntax)base.VisitInterpolation(node); if (result.Expression != null && !result.Expression.IsKind(SyntaxKind.ParenthesizedExpression)) { result = result.WithExpression(result.Expression.Parenthesize()); } return(result); }
public static async Task <Document> RefactorAsync( Document document, InterpolationSyntax interpolation, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxNode newRoot = root.RemoveNode(interpolation, SyntaxRemoveOptions.KeepUnbalancedDirectives); return(document.WithSyntaxRoot(newRoot)); }
public override SyntaxNode VisitInterpolatedStringExpression(InterpolatedStringExpressionSyntax node) { return(node.Contents.Count() == 1 ? node.Contents.Single() switch { InterpolationSyntax interpolation => interpolation.Expression, InterpolatedStringTextSyntax interpolatedStringText => interpolatedStringText.TextToken.Text.ToLiteralExpression(), _ => throw new NotSupportedException() }
private void FindInterpolatedStrings(SyntaxNode syntaxNode, SemanticModel model, ref List <VulnerabilityDetail> vulnerabilities) { var interpolatedStrings = syntaxNode.DescendantNodes().OfType <InterpolatedStringExpressionSyntax>(); foreach (var interpolatedString in interpolatedStrings) { string variableValue = interpolatedString.Contents.JoinStr(null, x => x switch { InterpolationSyntax interpolation => model.GetConstantValue(interpolation.Expression) is { } optional && optional.HasValue && optional.Value is string value ? value : null, InterpolatedStringTextSyntax text => text.TextToken.ToString(), _ => null } ?? CredentialSeparator.ToString());
internal static void Analyze(SyntaxNodeAnalysisContext context, InterpolationSyntax interpolation) { ExpressionSyntax expression = interpolation.Expression; if (expression?.IsKind(SyntaxKind.ParenthesizedExpression) == true) { var parenthesizedExpression = (ParenthesizedExpressionSyntax)expression; if (parenthesizedExpression.Expression?.IsKind(SyntaxKind.ConditionalExpression) == false) { AnalyzeParenthesizedExpression(context, parenthesizedExpression); } } }
public override void VisitInterpolation(InterpolationSyntax node) { if (!PreVisit(node)) { return; } node.AlignmentClause?.Accept(this); node.FormatClause?.Accept(this); node.Expression?.Accept(this); base.VisitInterpolation(node); PostVisit(node); }
public override SyntaxNode VisitInterpolation(InterpolationSyntax node) { var literalExpression = node.Expression as LiteralExpressionSyntax; if (literalExpression != null && literalExpression.IsKind(SyntaxKind.NumericLiteralExpression)) { var index = (int)literalExpression.Token.Value; if (index >= 0 && index < expandedArguments.Length) { return(node.WithExpression(expandedArguments[index])); } } return(base.VisitInterpolation(node)); }
public static void ComputeRefactorings(RefactoringContext context, InterpolationSyntax interpolation) { 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 override SyntaxNode VisitInterpolation(InterpolationSyntax node) { ExpressionSyntax expression = node.Expression; if (expression?.Kind() == SyntaxKind.NumericLiteralExpression) { var literalExpression = (LiteralExpressionSyntax)expression; var index = (int)literalExpression.Token.Value; if (index >= 0 && index < _interpolationExpressions.Length) { return(node.WithExpression(_interpolationExpressions[index])); } } return(base.VisitInterpolation(node)); }
public static Task <Document> RefactorAsync( Document document, InterpolationSyntax interpolation, CancellationToken cancellationToken = default(CancellationToken)) { var interpolatedString = (InterpolatedStringExpressionSyntax)interpolation.Parent; string s = interpolatedString.ToString(); s = s.Substring(0, interpolation.SpanStart - interpolatedString.SpanStart) + StringUtility.DoubleBraces(SyntaxInfo.StringLiteralExpressionInfo(interpolation.Expression).InnerText) + s.Substring(interpolation.Span.End - interpolatedString.SpanStart); var newInterpolatedString = (InterpolatedStringExpressionSyntax)SyntaxFactory.ParseExpression(s) .WithTriviaFrom(interpolatedString); return(document.ReplaceNodeAsync(interpolatedString, newInterpolatedString, cancellationToken)); }
private void AnalyzeInterpolation(SyntaxNodeAnalysisContext context) { InterpolationSyntax syntax = (InterpolationSyntax)context.Node; var type = context.SemanticModel.GetTypeInfo(syntax.Expression); if (IsItAlreadyObject(type, context)) { return; } if (HasToStringOverride(type, context)) { return; } context.ReportDiagnostic(Diagnostic.Create(Rule, syntax.GetLocation())); }
public override SyntaxNode VisitInterpolation(InterpolationSyntax node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } var literalExpression = node.Expression as LiteralExpressionSyntax; if (literalExpression?.IsKind(SyntaxKind.NumericLiteralExpression) == true) { var index = (int)literalExpression.Token.Value; if (index >= 0 && index < _expandedArguments.Length) { return(node.WithExpression(_expandedArguments[index])); } } return(base.VisitInterpolation(node)); }
private static bool IgnoreInterpolation(SourceText text, int offset, InterpolationSyntax interpolation) { // We can ignore the hole if all the content of it is after the region's indentation level. // In that case, it's fine to draw the line through the hole as it won't intersect any code // (or show up on the right side of the line). var holeStartLine = text.Lines.GetLineFromPosition(interpolation.SpanStart).LineNumber; var holeEndLine = text.Lines.GetLineFromPosition(interpolation.Span.End).LineNumber; for (var i = holeStartLine; i <= holeEndLine; i++) { var line = text.Lines[i]; var currentLineOffset = line.GetFirstNonWhitespaceOffset(); if (currentLineOffset != null && currentLineOffset < offset) { return(false); } } return(true); }
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)); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); InterpolationSyntax interpolation = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <InterpolationSyntax>(); Debug.Assert(interpolation != null, $"{nameof(interpolation)} is null"); if (interpolation == null) { return; } string innerText = SyntaxUtility.GetStringLiteralInnerText((LiteralExpressionSyntax)interpolation.Expression); CodeAction codeAction = CodeAction.Create( $"Merge '{innerText}' into interpolated string", cancellationToken => MergeInterpolationIntoInterpolatedStringRefactoring.RefactorAsync(context.Document, interpolation, cancellationToken), DiagnosticIdentifiers.MergeInterpolationIntoInterpolatedString + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
public override SyntaxNode VisitInterpolation(InterpolationSyntax node) { node = (InterpolationSyntax)base.VisitInterpolation(node); Classes.Add(node); return(node); }
public override SyntaxNode VisitInterpolation(InterpolationSyntax node) { var result = (InterpolationSyntax)base.VisitInterpolation(node); if (result.Expression != null && !result.Expression.IsKind(SyntaxKind.ParenthesizedExpression)) { result = result.WithExpression(result.Expression.Parenthesize()); } return result; }
private static bool RemovalMayIntroduceInterpolationAmbiguity(ParenthesizedExpressionSyntax node) { // First, find the parenting interpolation. If we find a parenthesize expression first, // we can bail out early. InterpolationSyntax interpolation = null; foreach (var ancestor in node.Parent.AncestorsAndSelf()) { if (ancestor.IsKind(SyntaxKind.ParenthesizedExpression)) { return(false); } if (ancestor.IsKind(SyntaxKind.Interpolation)) { interpolation = (InterpolationSyntax)ancestor; break; } } if (interpolation == null) { return(false); } // In order determine whether removing this parenthesized expression will introduce a // parsing ambiguity, we must dig into the child tokens and nodes to determine whether // they include any : or :: tokens. If they do, we can't remove the parentheses because // the parser would assume that the first : would begin the format clause of the interpolation. var stack = s_nodeStackPool.AllocateAndClear(); try { stack.Push(node.Expression); while (stack.Count > 0) { var expression = stack.Pop(); foreach (var nodeOrToken in expression.ChildNodesAndTokens()) { // Note: There's no need drill into other parenthesized expressions, since any colons in them would be unambiguous. if (nodeOrToken.IsNode && !nodeOrToken.IsKind(SyntaxKind.ParenthesizedExpression)) { stack.Push(nodeOrToken.AsNode()); } else if (nodeOrToken.IsToken) { if (nodeOrToken.IsKind(SyntaxKind.ColonToken) || nodeOrToken.IsKind(SyntaxKind.ColonColonToken)) { return(true); } } } } } finally { s_nodeStackPool.ClearAndFree(stack); } return(false); }
public override SyntaxNode VisitInterpolation(InterpolationSyntax node) { var literalExpression = node.Expression as LiteralExpressionSyntax; if (literalExpression != null && literalExpression.IsKind(SyntaxKind.NumericLiteralExpression)) { var index = (int)literalExpression.Token.Value; if (index >= 0 && index < expandedArguments.Length) { return node.WithExpression(expandedArguments[index]); } } return base.VisitInterpolation(node); }
/// <inheritdoc /> public override Expression VisitInterpolation(InterpolationSyntax node) { throw Unexpected(node, nameof(VisitInterpolatedStringExpression)); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitInterpolation(InterpolationSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitInterpolation(node); }
public override void VisitInterpolation(InterpolationSyntax node) { Log(node, "Unsupported Syntax !"); }
private bool ReplacementBreaksInterpolation(InterpolationSyntax interpolation, InterpolationSyntax newInterpolation) { return(!TypesAreCompatible(interpolation.Expression, newInterpolation.Expression)); }
public override void VisitInterpolation(InterpolationSyntax node) { throw new NotImplementedException(); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitInterpolation(InterpolationSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitInterpolation(node); }