private static bool IsComment(SyntaxTrivia trivia)
{
return trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) ||
trivia.IsKind(SyntaxKind.MultiLineCommentTrivia) ||
trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) ||
trivia.IsKind(SyntaxKind.MultiLineDocumentationCommentTrivia);
}
public override SyntaxTrivia VisitTrivia(SyntaxTrivia trivia)
{
var retVal = default(SyntaxTrivia);
var isRegionOrEndRegionStructuredTrivia = trivia.HasStructure &&
(trivia.IsKind(SyntaxKind.RegionDirectiveTrivia) ||
trivia.IsKind(SyntaxKind.EndRegionDirectiveTrivia));
if (isRegionOrEndRegionStructuredTrivia)
{
this.addedAnnotations = true;
// Simply return default(SyntaxTrivia)
}
else
{
retVal = base.VisitTrivia(trivia);
}
return retVal;
}
protected override bool IsTriviaComment(SyntaxTrivia trivia) => trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) || trivia.IsKind(SyntaxKind.MultiLineCommentTrivia);
protected override bool IsTriviaComment(SyntaxTrivia trivia) => trivia.IsKind(SyntaxKind.CommentTrivia);
private static bool IsWhitespace(this SyntaxTrivia x)
{
return(x.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.WhitespaceTrivia) || x.IsKind(SyntaxKind.WhitespaceTrivia));
}
private static bool IsCommentTrivia(SyntaxTrivia trivia)
{
return(trivia.IsKind(SyntaxKind.MultiLineCommentTrivia) || trivia.IsKind(SyntaxKind.SingleLineCommentTrivia));
}
static bool TryGetDirective(SyntaxNode root, TextSpan span, out SyntaxTrivia directive)
{
directive = root.FindTrivia(span.Start);
return directive.IsKind(SyntaxKind.RegionDirectiveTrivia) || directive.IsKind(SyntaxKind.EndRegionDirectiveTrivia);
}
private static bool IsComment(SyntaxTrivia syntaxTrivia)
{
var isSingleLineComment = syntaxTrivia.IsKind(SyntaxKind.SingleLineCommentTrivia)
&& !syntaxTrivia.ToFullString().StartsWith(@"////", StringComparison.Ordinal);
return isSingleLineComment
|| syntaxTrivia.IsKind(SyntaxKind.MultiLineCommentTrivia);
}
public override void VisitTrivia (SyntaxTrivia trivia)
{
base.VisitTrivia (trivia);
if (trivia.IsKind (SyntaxKind.RegionDirectiveTrivia)) {
regionStack.Push (trivia);
} else if (trivia.IsKind (SyntaxKind.EndRegionDirectiveTrivia)) {
if (regionStack.Count == 0)
return;
var regionStart = regionStack.Pop ();
try {
var first = regionStart.GetLocation ().GetLineSpan ();
var last = trivia.GetLocation ().GetLineSpan ();
var v = regionStart.ToString ();
v = v.Substring ("#region".Length).Trim ();
if (v.Length == 0)
v = "...";
Foldings.Add (new FoldingRegion(v, new DocumentRegion(first.StartLinePosition, last.EndLinePosition), FoldType.UserRegion, true));
} catch (ArgumentOutOfRangeException) { }
}
}
/// <summary>
/// Is this any trivia element which represents a new line
/// </summary>
internal static bool IsAnyEndOfLine(this SyntaxTrivia trivia)
{
return(trivia.IsKind(SyntaxKind.EndOfLineTrivia) || trivia.IsDirective);
}
public static bool IsWhitespace(this SyntaxTrivia x)
{
return(x.IsKind(VBasic.SyntaxKind.WhitespaceTrivia) || x.IsKind(CS.SyntaxKind.WhitespaceTrivia));
}
public static bool IsEndOfLine(this SyntaxTrivia x)
{
return(x.IsKind(VBasic.SyntaxKind.EndOfLineTrivia) || x.IsKind(CS.SyntaxKind.EndOfLineTrivia));
}
/// <remarks>Good candidate for unit testing to catch newline issues hidden by the test harness</remarks>
public static string GetCommentText(this SyntaxTrivia trivia)
{
var commentText = trivia.ToString();
if (trivia.IsKind(CS.SyntaxKind.SingleLineCommentTrivia))
{
if (commentText.StartsWith("//"))
{
commentText = commentText.Substring(2);
}
return(commentText.TrimStart(null));
}
else if (trivia.IsKind(VBasic.SyntaxKind.CommentTrivia))
{
if (commentText.StartsWith("'") || commentText.StartsWith("’"))
{
commentText = commentText.Substring(1);
}
return(commentText.TrimStart(null));
}
else if (CS.CSharpExtensions.Kind(trivia) == CS.SyntaxKind.MultiLineCommentTrivia)
{
var textBuilder = new StringBuilder();
if (commentText.EndsWith("*/"))
{
commentText = commentText.Substring(0, commentText.Length - 2);
}
if (commentText.StartsWith("/*"))
{
commentText = commentText.Substring(2);
}
commentText = commentText.Trim();
var newLine = Environment.NewLine;
var lines = commentText.Split(new[] { newLine }, StringSplitOptions.None);
foreach (var line in lines)
{
var trimmedLine = line.Trim();
// Note: we trim leading '*' characters in multi-line comments.
// If the '*' was intentional, sorry, it's gone.
if (trimmedLine.StartsWith("*"))
{
trimmedLine = trimmedLine.TrimStart('*');
trimmedLine = trimmedLine.TrimStart(null);
}
textBuilder.AppendLine(trimmedLine);
}
// remove last line break
textBuilder.Remove(textBuilder.Length - newLine.Length, newLine.Length);
return(textBuilder.ToString());
}
else if (trivia.IsKind(VBasic.SyntaxKind.DocumentationCommentTrivia) || CS.CSharpExtensions.Kind(trivia) == CS.SyntaxKind.SingleLineDocumentationCommentTrivia)
{
var textBuilder = new StringBuilder();
if (commentText.EndsWith("*/"))
{
commentText = commentText.TrimEnd('\'');
}
if (commentText.StartsWith("'''"))
{
commentText = commentText.TrimStart('\'');
}
commentText = commentText.Trim();
var lines = commentText.Replace("\r\n", "\n").Split('\n');
foreach (var line in lines)
{
var trimmedLine = line.Trim();
// Note: we trim leading ' characters in multi-line comments.
// If the ' was intentional, sorry, it's gone.
if (trimmedLine.StartsWith("'"))
{
trimmedLine = trimmedLine.TrimStart('\'');
trimmedLine = trimmedLine.TrimStart(null);
}
if (trimmedLine.StartsWith("/"))
{
trimmedLine = trimmedLine.TrimStart('/');
trimmedLine = trimmedLine.TrimStart(null);
}
textBuilder.AppendLine(trimmedLine);
}
return(textBuilder.ToString().TrimEnd());
}
throw new NotImplementedException($"Comment cannot be parsed:\r\n'{commentText}'");
}
internal SyntaxTrivia ConvertTrivia(SyntaxTrivia t)
{
var switchExpr = t.RawKind;
/* TODO ERROR: Skipped RegionDirectiveTrivia */
switch (switchExpr)
{
case (int)CS.SyntaxKind.WhitespaceTrivia: {
return(VBFactory.WhitespaceTrivia(t.ToString()));
}
case (int)CS.SyntaxKind.EndOfLineTrivia: {
return(global::VisualBasicSyntaxFactory.VBEOLTrivia);
}
case (int)CS.SyntaxKind.SingleLineCommentTrivia: {
if (t.ToFullString().EndsWith("*/"))
{
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2, t.ToFullString().Length - 4))}"));
}
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2))}"));
}
case (int)CS.SyntaxKind.MultiLineCommentTrivia: {
if (t.ToFullString().EndsWith("*/"))
{
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2, t.ToFullString().Length - 4)).Replace(Constants.vbLf, "").Replace(Constants.vbCr, "")}"));
}
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2)).Replace(Constants.vbLf, "").Replace(Constants.vbCr, "")}"));
}
case (int)CS.SyntaxKind.DocumentationCommentExteriorTrivia: {
return(VBFactory.SyntaxTrivia(VB.SyntaxKind.CommentTrivia, "'''"));
}
case (int)CS.SyntaxKind.DisabledTextTrivia: {
if (TriviaDepth > 0)
{
return(VBFactory.DisabledTextTrivia(t.ToString().WithoutNewLines(' ')));
}
return(VBFactory.DisabledTextTrivia(t.ToString().ConsistentNewlines()));
}
case (int)CS.SyntaxKind.PreprocessingMessageTrivia: {
return(VBFactory.CommentTrivia($" ' {t}"));
}
case (int)CS.SyntaxKind.None: {
return(default(SyntaxTrivia));
}
}
/* TODO ERROR: Skipped EndRegionDirectiveTrivia */
/* TODO ERROR: Skipped RegionDirectiveTrivia */
CSS.StructuredTriviaSyntax StructuredTrivia = (CSS.StructuredTriviaSyntax)t.GetStructure();
Debug.Assert(StructuredTrivia != null, $"Found new type of non structured trivia {t.RawKind}");
var switchExpr1 = t.RawKind;
switch (switchExpr1)
{
case (int)CS.SyntaxKind.DefineDirectiveTrivia: {
CSS.DefineDirectiveTriviaSyntax DefineDirective = (CSS.DefineDirectiveTriviaSyntax)StructuredTrivia;
var Name = VBFactory.Identifier(DefineDirective.Name.ValueText);
VBS.ExpressionSyntax value = VBFactory.TrueLiteralExpression(global::VisualBasicSyntaxFactory.TrueKeyword);
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(WithConvertedTriviaFrom(VBFactory.ConstDirectiveTrivia(Name, value), DefineDirective), DefineDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.UndefDirectiveTrivia: {
CSS.UndefDirectiveTriviaSyntax UndefineDirective = (CSS.UndefDirectiveTriviaSyntax)StructuredTrivia;
var Name = VBFactory.Identifier(UndefineDirective.Name.ValueText);
VBS.ExpressionSyntax value = global::VisualBasicSyntaxFactory.NothingExpression;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(WithConvertedTriviaFrom(VBFactory.ConstDirectiveTrivia(Name, value), UndefineDirective), UndefineDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.EndIfDirectiveTrivia: {
if (TriviaDepth > 0)
{
TriviaDepth -= 1;
return(VBFactory.CommentTrivia($"' TODO VB does not allow directives here, original statement {t.ToFullString().WithoutNewLines(' ')}"));
}
CSS.EndIfDirectiveTriviaSyntax EndIfDirective = (CSS.EndIfDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.EndIfDirectiveTrivia().WithConvertedTrailingTriviaFrom(EndIfDirective.EndIfKeyword), EndIfDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.ErrorDirectiveTrivia: {
CSS.ErrorDirectiveTriviaSyntax ErrorDirective = (CSS.ErrorDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.CommentTrivia($"' TODO: Check VB does not support Error Directive Trivia, Original Directive {ErrorDirective.ToFullString()}"));
}
case (int)CS.SyntaxKind.IfDirectiveTrivia: {
if (t.Token.Parent?.AncestorsAndSelf().OfType <CSS.InitializerExpressionSyntax>().Any() == true)
{
TriviaDepth += 1;
}
CSS.IfDirectiveTriviaSyntax IfDirective = (CSS.IfDirectiveTriviaSyntax)StructuredTrivia;
string Expression1 = StringReplaceCondition(IfDirective.Condition.ToString());
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.IfDirectiveTrivia(global::VisualBasicSyntaxFactory.IfKeyword, VBFactory.ParseExpression(Expression1)).With(IfDirective.GetLeadingTrivia().ConvertTrivia(), IfDirective.Condition.GetTrailingTrivia().ConvertTrivia()), IfDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.ElifDirectiveTrivia: {
if (t.Token.Parent.AncestorsAndSelf().OfType <CSS.InitializerExpressionSyntax>().Any())
{
TriviaDepth += 1;
}
CSS.ElifDirectiveTriviaSyntax ELIfDirective = (CSS.ElifDirectiveTriviaSyntax)StructuredTrivia;
string Expression1 = StringReplaceCondition(ELIfDirective.Condition.ToString());
SyntaxToken IfOrElseIfKeyword;
if (t.IsKind(CS.SyntaxKind.ElifDirectiveTrivia))
{
IfOrElseIfKeyword = global::VisualBasicSyntaxFactory.ElseIfKeyword;
}
else
{
IfOrElseIfKeyword = global::VisualBasicSyntaxFactory.IfKeyword;
}
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.ElseIfDirectiveTrivia(IfOrElseIfKeyword, VBFactory.ParseExpression(Expression1))
.With(ELIfDirective.GetLeadingTrivia().ConvertTrivia(), ELIfDirective.Condition.GetTrailingTrivia().ConvertTrivia())
, ELIfDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.LineDirectiveTrivia: {
return(VBFactory.CommentTrivia($"' TODO: Check VB does not support Line Directive Trivia, Original Directive {t}"));
}
case (int)CS.SyntaxKind.ElseDirectiveTrivia: {
return(VBFactory.Trivia(WithTrailingEOL(VBFactory.ElseDirectiveTrivia().NormalizeWhitespace().WithConvertedTrailingTriviaFrom(((CSS.ElseDirectiveTriviaSyntax)StructuredTrivia).ElseKeyword))));
}
case (int)CS.SyntaxKind.EndRegionDirectiveTrivia: {
CSS.EndRegionDirectiveTriviaSyntax EndRegionDirective = (CSS.EndRegionDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.EndRegionDirectiveTrivia(global::VisualBasicSyntaxFactory.HashToken, global::VisualBasicSyntaxFactory.EndKeyword, global::VisualBasicSyntaxFactory.RegionKeyword), EndRegionDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.PragmaWarningDirectiveTrivia: {
// Dim PragmaWarningDirectiveTrivia As CSS.PragmaWarningDirectiveTriviaSyntax = DirectCast(StructuredTrivia, CSS.PragmaWarningDirectiveTriviaSyntax)
// Dim ErrorList As New List(Of VBS.IdentifierNameSyntax)
// Dim TrailingTriviaStringBuilder As New StringBuilder
// For Each i As CSS.ExpressionSyntax In PragmaWarningDirectiveTrivia.ErrorCodes
// Dim ErrorCode As String = i.ToString
// If ErrorCode.IsInteger Then
// ErrorCode = $"CS_{ErrorCode}"
// End If
// ErrorList.Add(VBFactory.IdentifierName(ErrorCode))
// For Each Trivial As SyntaxTrivia In i.GetTrailingTrivia
// TrailingTriviaStringBuilder.Append(Trivial.ToString)
// Next
// Next
// Dim WarningDirectiveTrivia As VBS.DirectiveTriviaSyntax
// If PragmaWarningDirectiveTrivia.DisableOrRestoreKeyword.IsKind(CS.SyntaxKind.DisableKeyword) Then
// WarningDirectiveTrivia = VBFactory.DisableWarningDirectiveTrivia(ErrorList.ToArray)
// Else
// WarningDirectiveTrivia = VBFactory.EnableWarningDirectiveTrivia(ErrorList.ToArray)
// End If
// Return VBFactory.CommentTrivia($" ' TODO {WarningDirectiveTrivia.NormalizeWhitespace}{TrailingTriviaStringBuilder.ToString}")
return(default(SyntaxTrivia));
}
case (int)CS.SyntaxKind.RegionDirectiveTrivia: {
CSS.RegionDirectiveTriviaSyntax RegionDirective = (CSS.RegionDirectiveTriviaSyntax)StructuredTrivia;
var EndOfDirectiveToken = RegionDirective.EndOfDirectiveToken;
string NameString = $"\"{EndOfDirectiveToken.LeadingTrivia.ToString().Replace("\"", "")}\"";
var RegionDirectiveTriviaNode = VBFactory.RegionDirectiveTrivia(global::VisualBasicSyntaxFactory.HashToken, global::VisualBasicSyntaxFactory.RegionKeyword, VBFactory.StringLiteralToken(NameString, NameString)
).WithConvertedTrailingTriviaFrom(EndOfDirectiveToken);
return(VBFactory.Trivia(WithTrailingEOL(RegionDirectiveTriviaNode)));
}
case (int)CS.SyntaxKind.SingleLineDocumentationCommentTrivia: {
CSS.DocumentationCommentTriviaSyntax SingleLineDocumentationComment = (CSS.DocumentationCommentTriviaSyntax)StructuredTrivia;
var walker = new XMLVisitor();
walker.Visit(SingleLineDocumentationComment);
var xmlNodes = new List <VBS.XmlNodeSyntax>();
for (int i = 0, loopTo = SingleLineDocumentationComment.Content.Count - 1; i <= loopTo; i++)
{
var node = SingleLineDocumentationComment.Content[i];
if (!node.IsKind(CS.SyntaxKind.XmlText) && node.GetLeadingTrivia().Count > 0 && node.GetLeadingTrivia().First().IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia))
{
if (i < SingleLineDocumentationComment.Content.Count - 1)
{
var NextNode = SingleLineDocumentationComment.Content[i + 1];
if (!NextNode.IsKind(CS.SyntaxKind.XmlText) || NextNode.GetLeadingTrivia().Count == 0 || !NextNode.GetLeadingTrivia().First().IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia))
{
xmlNodes.Add(VBFactory.XmlText(" ").WithLeadingTrivia(VBFactory.DocumentationCommentExteriorTrivia("'''")));
}
}
node = node.WithoutLeadingTrivia();
}
VBS.XmlNodeSyntax Item = (VBS.XmlNodeSyntax)node.Accept(walker);
xmlNodes.Add(Item);
}
var DocumentationCommentTrivia = VBFactory.DocumentationCommentTrivia(VBFactory.List(xmlNodes.ToArray()));
if (!DocumentationCommentTrivia.HasLeadingTrivia || !DocumentationCommentTrivia.GetLeadingTrivia()[0].IsKind(VB.SyntaxKind.DocumentationCommentExteriorTrivia))
{
DocumentationCommentTrivia = DocumentationCommentTrivia.WithLeadingTrivia(VBFactory.DocumentationCommentExteriorTrivia("''' "));
}
var _DocumentationComment = VBFactory.Trivia(DocumentationCommentTrivia.WithTrailingTrivia(VBFactory.EndOfLine("")));
return(_DocumentationComment);
}
case (int)CS.SyntaxKind.PragmaChecksumDirectiveTrivia: {
CSS.PragmaChecksumDirectiveTriviaSyntax PragmaChecksumDirective = (CSS.PragmaChecksumDirectiveTriviaSyntax)StructuredTrivia;
var Guid1 = VBFactory.ParseToken(PragmaChecksumDirective.Guid.Text.ToUpperInvariant());
var Bytes = VBFactory.ParseToken(PragmaChecksumDirective.Bytes.Text);
var ExternalSource = VBFactory.ParseToken(PragmaChecksumDirective.File.Text);
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(
VBFactory.ExternalChecksumDirectiveTrivia(global::VisualBasicSyntaxFactory.HashToken, global::VisualBasicSyntaxFactory.ExternalChecksumKeyword, global::VisualBasicSyntaxFactory.OpenParenToken, ExternalSource, global::VisualBasicSyntaxFactory.CommaToken, Guid1, global::VisualBasicSyntaxFactory.CommaToken, Bytes, global::VisualBasicSyntaxFactory.CloseParenToken), PragmaChecksumDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.SkippedTokensTrivia: {
var Builder = new StringBuilder();
foreach (SyntaxToken tok in ((CSS.SkippedTokensTriviaSyntax)StructuredTrivia).Tokens)
{
Builder.Append(tok.ToString());
}
return(VBFactory.CommentTrivia($"' TODO: Error SkippedTokensTrivia '{Builder}'"));
}
case (int)CS.SyntaxKind.BadDirectiveTrivia: {
return(VBFactory.CommentTrivia($"' TODO: Skipped BadDirectiveTrivia"));
}
case (int)CS.SyntaxKind.ConflictMarkerTrivia: {
break;
}
case (int)CS.SyntaxKind.LoadDirectiveTrivia: {
break;
}
default: {
Debug.WriteLine(((VB.SyntaxKind)Conversions.ToUShort(t.RawKind)).ToString());
break;
}
}
throw new NotImplementedException($"t.Kind({(VB.SyntaxKind)Conversions.ToUShort(t.RawKind)}) Is unknown");
}
private bool IsComment(SyntaxTrivia syntaxTrivia)
{
var isSingleLineComment = syntaxTrivia.IsKind(SyntaxKind.SingleLineCommentTrivia)
&& !syntaxTrivia.ToFullString().StartsWith(@"////");
return isSingleLineComment
|| syntaxTrivia.IsKind(SyntaxKind.MultiLineCommentTrivia);
}
private bool IsCodeComment(SyntaxTrivia trivia)
{
return trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) ||
trivia.IsKind(SyntaxKind.MultiLineCommentTrivia);
}
public static bool IsDocumentationTrivia(this SyntaxTrivia trivia) => trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) || trivia.IsKind(SyntaxKind.MultiLineDocumentationCommentTrivia);
private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context)
{
if (context.Tree.IsWhitespaceOnly(context.CancellationToken))
{
// Handling of empty documents is now the responsibility of the analyzers
return;
}
var root = context.Tree.GetRoot(context.CancellationToken);
var text = context.Tree.GetText(context.CancellationToken);
SyntaxTrivia previousTrivia = default;
foreach (var trivia in root.DescendantTrivia(descendIntoTrivia: true))
{
switch (trivia.Kind())
{
case SyntaxKind.WhitespaceTrivia:
break;
case SyntaxKind.EndOfLineTrivia:
if (previousTrivia.Span.End < trivia.SpanStart)
{
// Some token appeared between the previous trivia and the end of the line.
break;
}
if (previousTrivia.IsKind(SyntaxKind.WhitespaceTrivia))
{
// Report warning for whitespace token followed by the end of a line
context.ReportDiagnostic(Diagnostic.Create(Descriptor, previousTrivia.GetLocation()));
}
else if (previousTrivia.IsKind(SyntaxKind.PreprocessingMessageTrivia))
{
TextSpan trailinMessageWhitespace = FindTrailingWhitespace(text, previousTrivia.Span);
if (!trailinMessageWhitespace.IsEmpty)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, Location.Create(context.Tree, trailinMessageWhitespace)));
}
}
break;
case SyntaxKind.SingleLineCommentTrivia:
TextSpan trailingWhitespace = FindTrailingWhitespace(text, trivia.Span);
if (!trailingWhitespace.IsEmpty)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, Location.Create(context.Tree, trailingWhitespace)));
}
break;
case SyntaxKind.MultiLineCommentTrivia:
var line = text.Lines.GetLineFromPosition(trivia.Span.Start);
while (line.End <= trivia.Span.End)
{
trailingWhitespace = FindTrailingWhitespace(text, line.Span);
if (!trailingWhitespace.IsEmpty)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, Location.Create(context.Tree, trailingWhitespace)));
}
if (line.EndIncludingLineBreak == text.Length)
{
// We've reached the end of the document.
break;
}
line = text.Lines.GetLineFromPosition(line.EndIncludingLineBreak + 1);
}
break;
case SyntaxKind.SingleLineDocumentationCommentTrivia:
case SyntaxKind.MultiLineDocumentationCommentTrivia:
SyntaxToken previousToken = default;
foreach (var token in trivia.GetStructure().DescendantTokens(descendIntoTrivia: true))
{
if (token.IsKind(SyntaxKind.XmlTextLiteralNewLineToken) &&
previousToken.IsKind(SyntaxKind.XmlTextLiteralToken) &&
previousToken.Span.End == token.SpanStart)
{
trailingWhitespace = FindTrailingWhitespace(text, previousToken.Span);
if (!trailingWhitespace.IsEmpty)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, Location.Create(context.Tree, trailingWhitespace)));
}
}
previousToken = token;
}
break;
default:
break;
}
previousTrivia = trivia;
}
if (previousTrivia.IsKind(SyntaxKind.WhitespaceTrivia) && previousTrivia.Span.End == previousTrivia.SyntaxTree.Length)
{
// Report whitespace at the end of the last line in the document
context.ReportDiagnostic(Diagnostic.Create(Descriptor, previousTrivia.GetLocation()));
}
}
private static void HandleSyntaxTree(SyntaxTreeAnalysisContext context, StyleCopSettings settings)
{
var endOfFileToken = context.Tree.GetRoot().GetLastToken(includeZeroWidth: true);
TextSpan reportedSpan = new TextSpan(endOfFileToken.SpanStart, 0);
SyntaxTrivia precedingTrivia = default(SyntaxTrivia);
bool checkPrecedingToken;
if (endOfFileToken.HasLeadingTrivia)
{
var leadingTrivia = endOfFileToken.LeadingTrivia;
var trailingWhitespaceIndex = TriviaHelper.IndexOfTrailingWhitespace(leadingTrivia);
if (trailingWhitespaceIndex > 0)
{
checkPrecedingToken = false;
reportedSpan = TextSpan.FromBounds(leadingTrivia[trailingWhitespaceIndex].SpanStart, reportedSpan.End);
precedingTrivia = leadingTrivia[trailingWhitespaceIndex - 1];
}
else if (trailingWhitespaceIndex == 0)
{
checkPrecedingToken = true;
reportedSpan = TextSpan.FromBounds(leadingTrivia[trailingWhitespaceIndex].SpanStart, reportedSpan.End);
}
else
{
checkPrecedingToken = false;
precedingTrivia = leadingTrivia.Last();
}
}
else
{
checkPrecedingToken = true;
}
if (checkPrecedingToken)
{
var previousToken = endOfFileToken.GetPreviousToken(includeZeroWidth: true, includeSkipped: true, includeDirectives: true, includeDocumentationComments: true);
var trailingWhitespaceIndex = TriviaHelper.IndexOfTrailingWhitespace(previousToken.TrailingTrivia);
if (trailingWhitespaceIndex > 0)
{
reportedSpan = TextSpan.FromBounds(previousToken.TrailingTrivia[trailingWhitespaceIndex].SpanStart, reportedSpan.End);
precedingTrivia = previousToken.TrailingTrivia[trailingWhitespaceIndex - 1];
}
else if (trailingWhitespaceIndex == 0)
{
reportedSpan = TextSpan.FromBounds(previousToken.TrailingTrivia[trailingWhitespaceIndex].SpanStart, reportedSpan.End);
precedingTrivia = default(SyntaxTrivia);
}
else
{
if (previousToken.TrailingTrivia.Count > 0)
{
precedingTrivia = previousToken.TrailingTrivia.Last();
}
}
}
if (precedingTrivia.IsDirective)
{
DirectiveTriviaSyntax directiveTriviaSyntax = precedingTrivia.GetStructure() as DirectiveTriviaSyntax;
if (directiveTriviaSyntax != null && directiveTriviaSyntax.EndOfDirectiveToken.HasTrailingTrivia)
{
var trailingWhitespaceIndex = TriviaHelper.IndexOfTrailingWhitespace(directiveTriviaSyntax.EndOfDirectiveToken.TrailingTrivia);
if (trailingWhitespaceIndex >= 0)
{
reportedSpan = TextSpan.FromBounds(directiveTriviaSyntax.EndOfDirectiveToken.TrailingTrivia[trailingWhitespaceIndex].SpanStart, reportedSpan.End);
}
}
}
else if (precedingTrivia.IsKind(SyntaxKind.EndOfLineTrivia))
{
reportedSpan = TextSpan.FromBounds(precedingTrivia.SpanStart, reportedSpan.End);
}
SourceText sourceText = context.Tree.GetText(context.CancellationToken);
string trailingWhitespaceText = sourceText.ToString(reportedSpan);
int firstNewline = trailingWhitespaceText.IndexOf('\n');
int secondNewline = firstNewline >= 0 ? trailingWhitespaceText.IndexOf('\n', firstNewline + 1) : -1;
DiagnosticDescriptor descriptorToReport;
switch (settings.LayoutRules.NewlineAtEndOfFile)
{
case OptionSetting.Omit:
if (firstNewline < 0)
{
return;
}
descriptorToReport = DescriptorOmit;
break;
case OptionSetting.Require:
if (firstNewline >= 0 && firstNewline == trailingWhitespaceText.Length - 1)
{
return;
}
descriptorToReport = DescriptorRequire;
break;
case OptionSetting.Allow:
default:
if (secondNewline < 0)
{
// 1. A newline is allowed but not required
// 2. If a newline is included, it cannot be followed by whitespace
if (firstNewline < 0 || firstNewline == trailingWhitespaceText.Length - 1)
{
return;
}
}
descriptorToReport = DescriptorAllow;
break;
}
context.ReportDiagnostic(Diagnostic.Create(descriptorToReport, Location.Create(context.Tree, reportedSpan)));
}
protected override bool IsTriviaComment(SyntaxTrivia trivia) =>
trivia.IsKind(SyntaxKind.CommentTrivia);
private static void AnalyzeSyntaxTree(SyntaxTreeAnalysisContext context)
{
SyntaxTree tree = context.Tree;
if (!tree.TryGetText(out SourceText sourceText))
{
return;
}
int maxLength = CSharp.AnalyzerOptions.MaxLineLength.GetInt32Value(context.Tree, context.Options, AnalyzerSettings.Current.MaxLineLength);
if (maxLength <= 0)
{
return;
}
SyntaxNode root = tree.GetRoot(context.CancellationToken);
int i = 0;
SyntaxTrivia trivia = root.FindTrivia(0);
if (trivia.SpanStart == 0 &&
trivia.IsKind(SyntaxKind.SingleLineCommentTrivia, SyntaxKind.MultiLineCommentTrivia))
{
SyntaxTriviaList leadingTrivia = trivia.Token.LeadingTrivia;
int count = leadingTrivia.Count;
if (count > 1)
{
int j = 0;
while (j < leadingTrivia.Count - 1 &&
leadingTrivia[j].IsKind(SyntaxKind.SingleLineCommentTrivia, SyntaxKind.MultiLineCommentTrivia) &&
leadingTrivia[j + 1].IsKind(SyntaxKind.EndOfLineTrivia))
{
i++;
j += 2;
}
}
}
TextLineCollection lines = sourceText.Lines;
for (; i < lines.Count; i++)
{
TextLine line = lines[i];
if (line.Span.Length <= maxLength)
{
continue;
}
int end = line.End;
SyntaxToken token = root.FindToken(end);
if (token.IsKind(SyntaxKind.StringLiteralToken))
{
TextSpan span = token.Span;
if (span.End == end)
{
if (span.Length >= maxLength)
{
continue;
}
}
else if (span.Contains(end) &&
end - span.Start >= maxLength)
{
continue;
}
}
SyntaxTriviaList list = default;
if (token.LeadingTrivia.Span.Contains(end))
{
list = token.LeadingTrivia;
}
else if (token.TrailingTrivia.Span.Contains(end))
{
list = token.TrailingTrivia;
}
if (list.Any())
{
int index = -1;
for (int j = 0; j < list.Count; j++)
{
if (list[j].Span.Contains(end))
{
trivia = list[j];
index = j;
}
}
if (index >= 0)
{
SyntaxKind kind = trivia.Kind();
if (kind == SyntaxKind.MultiLineCommentTrivia ||
kind == SyntaxKind.SingleLineDocumentationCommentTrivia ||
kind == SyntaxKind.MultiLineDocumentationCommentTrivia)
{
continue;
}
if (kind == SyntaxKind.EndOfLineTrivia &&
index > 0 &&
list[index - 1].IsKind(SyntaxKind.SingleLineCommentTrivia))
{
continue;
}
}
}
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.LineIsTooLong,
Location.Create(tree, line.Span),
line.Span.Length);
}
}
protected override ReadOnlyMemory <char> GetTextContextOfComment(SyntaxTrivia commentTrivia)
{
if (commentTrivia.IsKind(SyntaxKind.SingleLineCommentTrivia))
{
return(commentTrivia.ToFullString().AsMemory()[2..]);
private void AnalyzeTrailingTrivia(SyntaxTreeAnalysisContext context)
{
SourceText sourceText;
if (!context.Tree.TryGetText(out sourceText))
{
return;
}
SyntaxNode root;
if (!context.Tree.TryGetRoot(out root))
{
return;
}
var emptyLines = default(TextSpan);
bool previousLineIsEmpty = false;
int i = 0;
foreach (TextLine textLine in sourceText.Lines)
{
bool lineIsEmpty = false;
if (textLine.Span.Length == 0)
{
SyntaxTrivia endOfLine = root.FindTrivia(textLine.End);
if (endOfLine.IsKind(SyntaxKind.EndOfLineTrivia))
{
lineIsEmpty = true;
if (previousLineIsEmpty)
{
if (emptyLines.IsEmpty)
{
emptyLines = endOfLine.Span;
}
else
{
emptyLines = TextSpan.FromBounds(emptyLines.Start, endOfLine.Span.End);
}
}
}
else
{
emptyLines = default(TextSpan);
}
}
else
{
if (!emptyLines.IsEmpty)
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveRedundantEmptyLine,
Location.Create(context.Tree, emptyLines));
}
emptyLines = default(TextSpan);
int end = textLine.End - 1;
if (char.IsWhiteSpace(sourceText[end]))
{
int start = end;
while (start > textLine.Span.Start && char.IsWhiteSpace(sourceText[start - 1]))
{
start--;
}
TextSpan whitespace = TextSpan.FromBounds(start, end + 1);
if (root.FindTrivia(start).IsKind(SyntaxKind.WhitespaceTrivia))
{
if (previousLineIsEmpty && start == textLine.Start)
{
whitespace = TextSpan.FromBounds(
sourceText.Lines[i - 1].End,
whitespace.End);
}
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveTrailingWhitespace,
Location.Create(context.Tree, whitespace));
}
}
}
previousLineIsEmpty = lineIsEmpty;
i++;
}
}
public static bool IsEndOfLine(this SyntaxTrivia x)
{
return(x.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.EndOfLineTrivia) || x.IsKind(SyntaxKind.EndOfLineTrivia));
}
public static bool IsMultiLineComment(this SyntaxTrivia trivia)
{
return(trivia.IsKind(CS.SyntaxKind.MultiLineCommentTrivia) || trivia.IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia) || trivia.IsKind(CS.SyntaxKind.MultiLineDocumentationCommentTrivia));
}
public static string GetCommentText(this SyntaxTrivia trivia)
{
var commentText = trivia.ToString();
if (trivia.IsKind(SyntaxKind.SingleLineCommentTrivia))
{
if (commentText.StartsWith("//"))
{
commentText = commentText.Substring(2);
}
return(commentText.TrimStart(null));
}
else if (trivia.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.CommentTrivia))
{
if (commentText.StartsWith("'"))
{
commentText = commentText.Substring(1);
}
return(commentText.TrimStart(null));
}
else if (trivia.Kind() == SyntaxKind.MultiLineCommentTrivia)
{
var textBuilder = new StringBuilder();
if (commentText.EndsWith("*/"))
{
commentText = commentText.Substring(0, commentText.Length - 2);
}
if (commentText.StartsWith("/*"))
{
commentText = commentText.Substring(2);
}
commentText = commentText.Trim();
var newLine = Environment.NewLine;
var lines = commentText.Split(new[] { newLine }, StringSplitOptions.None);
foreach (var line in lines)
{
var trimmedLine = line.Trim();
// Note: we trim leading '*' characters in multi-line comments.
// If the '*' was intentional, sorry, it's gone.
if (trimmedLine.StartsWith("*"))
{
trimmedLine = trimmedLine.TrimStart('*');
trimmedLine = trimmedLine.TrimStart(null);
}
textBuilder.AppendLine(trimmedLine);
}
// remove last line break
textBuilder.Remove(textBuilder.Length - newLine.Length, newLine.Length);
return(textBuilder.ToString());
}
else if (trivia.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.DocumentationCommentTrivia))
{
var textBuilder = new StringBuilder();
if (commentText.EndsWith("*/"))
{
commentText = commentText.TrimEnd('\'');
}
if (commentText.StartsWith("'''"))
{
commentText = commentText.TrimStart('\'');
}
commentText = commentText.Trim();
var newLine = Environment.NewLine;
var lines = commentText.Split(new[] { newLine }, StringSplitOptions.None);
foreach (var line in lines)
{
var trimmedLine = line.Trim();
// Note: we trim leading ' characters in multi-line comments.
// If the ' was intentional, sorry, it's gone.
if (trimmedLine.StartsWith("'"))
{
trimmedLine = trimmedLine.TrimStart('\'');
trimmedLine = trimmedLine.TrimStart(null);
}
textBuilder.AppendLine(trimmedLine);
}
// remove last line break
textBuilder.Remove(textBuilder.Length - newLine.Length, newLine.Length);
return(textBuilder.ToString());
}
else
{
throw new InvalidOperationException();
}
}
public static bool IsSingleLineComment(this SyntaxTrivia trivia)
{
return(trivia.IsKind(CS.SyntaxKind.SingleLineCommentTrivia) || trivia.IsKind(CS.SyntaxKind.SingleLineDocumentationCommentTrivia) || trivia.IsKind(VBasic.SyntaxKind.CommentTrivia));
}
private static void AnalyzePragmaWarningDirectiveTrivia(SyntaxNodeAnalysisContext context)
{
var directive = (PragmaWarningDirectiveTriviaSyntax)context.Node;
SeparatedSyntaxList <ExpressionSyntax> errorCodes = directive.ErrorCodes;
int codeCount = errorCodes.Count;
if (codeCount == 0)
{
return;
}
if (codeCount == errorCodes.SeparatorCount)
{
if (!errorCodes.GetSeparator(codeCount - 1).TrailingTrivia.IsEmptyOrWhitespace())
{
return;
}
}
else if (!errorCodes.Last().GetTrailingTrivia().IsEmptyOrWhitespace())
{
return;
}
if (IsSuppressingThisAnalyzer(errorCodes))
{
return;
}
SyntaxTrivia trivia = directive.ParentTrivia;
if (!trivia.TryGetContainingList(out SyntaxTriviaList list))
{
return;
}
int count = list.Count;
if (count == 1)
{
return;
}
int index = list.IndexOf(trivia);
if (index == count - 1)
{
return;
}
int i = index - 1;
while (i >= 0 &&
list[i].IsWhitespaceOrEndOfLineTrivia())
{
i--;
}
if (i >= 0)
{
SyntaxTrivia directiveTrivia = list[i];
if (directiveTrivia.IsKind(SyntaxKind.PragmaWarningDirectiveTrivia))
{
var previousDirective = (PragmaWarningDirectiveTriviaSyntax)directiveTrivia.GetStructure();
if (!IsSuppressingThisAnalyzer(previousDirective.ErrorCodes))
{
return;
}
}
}
i = index + 1;
while (i < count &&
list[i].IsWhitespaceOrEndOfLineTrivia())
{
i++;
}
if (i == count)
{
return;
}
if (!list[i].IsKind(SyntaxKind.PragmaWarningDirectiveTrivia))
{
return;
}
if (!(list[i].GetStructure() is PragmaWarningDirectiveTriviaSyntax nextDirective))
{
return;
}
SyntaxToken disableOrRestoreKeyword = directive.DisableOrRestoreKeyword;
SyntaxKind keywordKind = disableOrRestoreKeyword.Kind();
if (keywordKind != nextDirective.DisableOrRestoreKeyword.Kind())
{
return;
}
if (keywordKind == SyntaxKind.DisableKeyword &&
IsSuppressingThisAnalyzer(nextDirective.ErrorCodes))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.MergePreprocessorDirectives, directive);
}
protected override LineColumnRule GetLineColumnRuleBetween(SyntaxTrivia trivia1, LineColumnDelta existingWhitespaceBetween, bool implicitLineBreak, SyntaxTrivia trivia2)
{
if (IsStartOrEndOfFile(trivia1, trivia2))
{
return(LineColumnRule.PreserveLinesWithAbsoluteIndentation(lines: 0, indentation: 0));
}
// [trivia] [whitespace] [token] case
if (trivia2.IsKind(SyntaxKind.None))
{
var insertNewLine = this.FormattingRules.GetAdjustNewLinesOperation(this.Token1, this.Token2) != null;
if (IsMultilineComment(trivia1))
{
return(LineColumnRule.PreserveLinesWithGivenIndentation(lines: insertNewLine ? 1 : 0));
}
if (insertNewLine)
{
return(LineColumnRule.PreserveLinesWithDefaultIndentation(lines: 0));
}
if (existingWhitespaceBetween.Lines > 0 && existingWhitespaceBetween.Spaces != this.Spaces)
{
return(LineColumnRule.PreserveWithGivenSpaces(spaces: this.Spaces));
}
return(LineColumnRule.Preserve);
}
// preprocessor case
if (SyntaxFacts.IsPreprocessorDirective(trivia2.Kind()))
{
// Check for immovable preprocessor directives, which are bad directive trivia
// without a preceding line break
if (trivia2.IsKind(SyntaxKind.BadDirectiveTrivia) && existingWhitespaceBetween.Lines == 0 && !implicitLineBreak)
{
_succeeded = false;
return(LineColumnRule.Preserve);
}
// if current line is the first line of the file, don't put extra line 1
var lines = (trivia1.IsKind(SyntaxKind.None) && this.Token1.IsKind(SyntaxKind.None)) ? 0 : 1;
if (trivia2.IsKind(SyntaxKind.RegionDirectiveTrivia) || trivia2.IsKind(SyntaxKind.EndRegionDirectiveTrivia))
{
return(LineColumnRule.PreserveLinesWithDefaultIndentation(lines));
}
return(LineColumnRule.PreserveLinesWithAbsoluteIndentation(lines, indentation: 0));
}
// comments case
if (trivia2.IsRegularOrDocComment())
{
// Start of new comments group.
//
// 1. Comment groups must contain the same kind of comments
// 2. Every block comment is a group of its own
if (!trivia1.IsKind(trivia2.Kind()) || trivia2.IsMultiLineComment() || trivia2.IsMultiLineDocComment() || existingWhitespaceBetween.Lines > 1)
{
if (this.FormattingRules.GetAdjustNewLinesOperation(this.Token1, this.Token2) != null)
{
return(LineColumnRule.PreserveLinesWithDefaultIndentation(lines: 0));
}
return(LineColumnRule.PreserveLinesWithGivenIndentation(lines: 0));
}
// comments after existing comment
if (existingWhitespaceBetween.Lines == 0)
{
return(LineColumnRule.PreserveLinesWithGivenIndentation(lines: 0));
}
return(LineColumnRule.PreserveLinesWithFollowingPrecedingIndentation);
}
if (trivia2.IsKind(SyntaxKind.SkippedTokensTrivia))
{
// if there is any skipped tokens, it is not possible to format this trivia range.
_succeeded = false;
}
return(LineColumnRule.Preserve);
}
/// <summary>
/// Is this trivia a SingleLineDocumentationCommentTrivia or a EndOfLineTrivia.
/// </summary>
/// <param name="trivia">The syntax trivia.</param>
/// <returns>True if yes otherwise false.</returns>
internal static bool HasBuiltinEndLine(this SyntaxTrivia trivia)
{
return(trivia.IsDirective ||
trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) ||
trivia.IsKind(SyntaxKind.EndOfLineTrivia));
}
protected override bool IsEndOfLine(SyntaxTrivia trivia) => trivia.IsKind(SyntaxKind.EndOfLineTrivia) || trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia);
private bool OnDisabledTextTrivia(SyntaxTrivia trivia, int index)
{
if (trivia.IsKind(SyntaxKind.DisabledTextTrivia))
{
var triviaString = trivia.ToString();
if (!string.IsNullOrEmpty(triviaString) && SyntaxFacts.IsNewLine(triviaString.Last()))
{
ResetStateAfterNewLine(index);
}
}
return false;
}
protected override bool IsRegularComment(SyntaxTrivia trivia)
{
return(trivia.IsKind(SyntaxKind.CommentTrivia));
}
public override void VisitTrivia (SyntaxTrivia trivia)
{
cancellationToken.ThrowIfCancellationRequested ();
if (trivia.IsKind (SyntaxKind.SingleLineCommentTrivia) ||
trivia.IsKind (SyntaxKind.MultiLineCommentTrivia) ||
trivia.IsKind (SyntaxKind.SingleLineDocumentationCommentTrivia)) {
var trimmedContent = trivia.ToString ().TrimStart ('/', ' ', '*');
foreach (string tag in tagComments) {
if (!trimmedContent.StartsWith (tag, StringComparison.Ordinal))
continue;
var loc = trivia.GetLocation ().GetLineSpan ();
Tags.Add (new Tag (tag, trimmedContent, new DocumentRegion (loc.StartLinePosition, loc.EndLinePosition)));
break;
}
}
}
public override SyntaxTrivia VisitTrivia(SyntaxTrivia trivia)
{
return(trivia.IsKind(SyntaxKind.EndOfLineTrivia)
? SyntaxFactory.CarriageReturnLineFeed
: base.VisitTrivia(trivia));
}
protected override LineColumnRule GetLineColumnRuleBetween(SyntaxTrivia trivia1, LineColumnDelta existingWhitespaceBetween, bool implicitLineBreak, SyntaxTrivia trivia2)
{
if (IsStartOrEndOfFile(trivia1, trivia2))
{
return LineColumnRule.PreserveLinesWithAbsoluteIndentation(lines: 0, indentation: 0);
}
// [trivia] [whitespace] [token] case
if (trivia2.IsKind(SyntaxKind.None))
{
var insertNewLine = this.FormattingRules.GetAdjustNewLinesOperation(this.Token1, this.Token2) != null;
if (IsMultilineComment(trivia1))
{
return LineColumnRule.PreserveLinesWithGivenIndentation(lines: insertNewLine ? 1 : 0);
}
if (insertNewLine)
{
return LineColumnRule.PreserveLinesWithDefaultIndentation(lines: 0);
}
if (existingWhitespaceBetween.Lines > 0 && existingWhitespaceBetween.Spaces != this.Spaces)
{
return LineColumnRule.PreserveWithGivenSpaces(spaces: this.Spaces);
}
return LineColumnRule.Preserve();
}
// preprocessor case
if (SyntaxFacts.IsPreprocessorDirective(trivia2.Kind()))
{
// Check for immovable preprocessor directives, which are bad directive trivia
// without a preceding line break
if (trivia2.IsKind(SyntaxKind.BadDirectiveTrivia) && existingWhitespaceBetween.Lines == 0 && !implicitLineBreak)
{
_succeeded = false;
return LineColumnRule.Preserve();
}
// if current line is the first line of the file, don't put extra line 1
var lines = (trivia1.IsKind(SyntaxKind.None) && this.Token1.IsKind(SyntaxKind.None)) ? 0 : 1;
if (trivia2.IsKind(SyntaxKind.RegionDirectiveTrivia) || trivia2.IsKind(SyntaxKind.EndRegionDirectiveTrivia))
{
return LineColumnRule.PreserveLinesWithDefaultIndentation(lines);
}
return LineColumnRule.PreserveLinesWithAbsoluteIndentation(lines, indentation: 0);
}
// comments case
if (trivia2.IsRegularOrDocComment())
{
// start of new comments group
if (!trivia1.IsRegularComment() || existingWhitespaceBetween.Lines > 1)
{
if (this.FormattingRules.GetAdjustNewLinesOperation(this.Token1, this.Token2) != null)
{
return LineColumnRule.PreserveLinesWithDefaultIndentation(lines: 0);
}
return LineColumnRule.PreserveLinesWithGivenIndentation(lines: 0);
}
// comments after existing comment
if (existingWhitespaceBetween.Lines == 0)
{
return LineColumnRule.PreserveLinesWithGivenIndentation(lines: 0);
}
return LineColumnRule.PreserveLinesWithFollowingPrecedingIndentation();
}
if (trivia2.IsKind(SyntaxKind.SkippedTokensTrivia))
{
// if there is any skipped tokens, it is not possible to format this trivia range.
_succeeded = false;
}
return LineColumnRule.Preserve();
}
public static bool IsTriviaAny(this SyntaxTrivia CSNode, params SyntaxKind [] CSKinds)
{
return(CSKinds.Any(csk => CSNode.IsKind(csk)));
}
static int SearchUsingInsertionPoint (SyntaxNode parent)
{
var result = 0;
foreach (SyntaxNode node in parent.ChildNodes ()) {
if (node.IsKind (Microsoft.CodeAnalysis.CSharp.SyntaxKind.UsingDirective)) {
result = node.FullSpan.End;
continue;
}
SyntaxTrivia last = new SyntaxTrivia ();
foreach (var trivia in node.GetLeadingTrivia ()) {
if (last.IsKind (Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineCommentTrivia)||
last.IsKind (Microsoft.CodeAnalysis.CSharp.SyntaxKind.DefineDirectiveTrivia) ||
last.IsKind (Microsoft.CodeAnalysis.CSharp.SyntaxKind.MultiLineCommentTrivia) ||
last.IsKind (Microsoft.CodeAnalysis.CSharp.SyntaxKind.SingleLineDocumentationCommentTrivia))
result = trivia.Span.End;
last = trivia;
}
break;
}
return result;
}
protected override bool IsDocComment(SyntaxTrivia trivia) => trivia.IsKind(SyntaxKind.DocumentationCommentTrivia);
private static bool IsAllowedTrivia(SyntaxTrivia trivia)
{
return trivia.IsKind(SyntaxKind.WhitespaceTrivia)
|| trivia.IsKind(SyntaxKind.EndOfLineTrivia)
|| (trivia.IsKind(SyntaxKind.MultiLineCommentTrivia) && !trivia.SpansMultipleLines());
}
protected override bool IsDocComment(SyntaxTrivia trivia) => trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) || trivia.IsKind(SyntaxKind.MultiLineDocumentationCommentTrivia);
private static string GetTriviaContent(SyntaxTrivia trivia)
{
var triviaContent = trivia.ToString();
if (trivia.IsKind(SyntaxKind.MultiLineCommentTrivia))
{
if (triviaContent.StartsWith("/*", StringComparison.InvariantCulture))
{
triviaContent = triviaContent.Substring(2);
}
if (triviaContent.EndsWith("*/", StringComparison.InvariantCulture))
{
triviaContent = triviaContent.Substring(0, triviaContent.Length-2);
}
return triviaContent;
}
if (trivia.IsKind(SyntaxKind.SingleLineCommentTrivia))
{
if (triviaContent.StartsWith("//", StringComparison.InvariantCulture))
{
triviaContent = triviaContent.Substring(2);
}
return triviaContent;
}
return string.Empty;
}
public static bool IsSingleOrMultiLineComment(this SyntaxTrivia trivia) => trivia.IsKind(SyntaxKind.MultiLineCommentTrivia) || trivia.IsKind(SyntaxKind.SingleLineCommentTrivia);
protected override bool IsTriviaComment(SyntaxTrivia trivia) =>
trivia.IsKind(SyntaxKind.SingleLineCommentTrivia) || trivia.IsKind(SyntaxKind.MultiLineCommentTrivia);
static bool TryGetDirective(SyntaxNode root, TextSpan span, out SyntaxTrivia directive)
{
directive = root.FindTrivia(span.Start);
return(directive.IsKind(SyntaxKind.RegionDirectiveTrivia) || directive.IsKind(SyntaxKind.EndRegionDirectiveTrivia));
}
