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))); }
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);
static bool TryGetDirective(SyntaxNode root, TextSpan span, out SyntaxTrivia directive) { directive = root.FindTrivia(span.Start); return(directive.IsKind(SyntaxKind.RegionDirectiveTrivia) || directive.IsKind(SyntaxKind.EndRegionDirectiveTrivia)); }