private void ClassifyTrivia(SyntaxTrivia trivia) { if (trivia.IsRegularComment()) { AddClassification(trivia, ClassificationTypeNames.Comment); } else if (trivia.Kind() == SyntaxKind.DisabledTextTrivia) { AddClassification(trivia, ClassificationTypeNames.ExcludedCode); } else if (trivia.Kind() == SyntaxKind.SkippedTokensTrivia) { ClassifySkippedTokens((SkippedTokensTriviaSyntax)trivia.GetStructure()); } else if (trivia.IsDocComment()) { ClassifyDocumentationComment((DocumentationCommentTriviaSyntax)trivia.GetStructure()); } else if (trivia.Kind() == SyntaxKind.DocumentationCommentExteriorTrivia) { AddClassification(trivia, ClassificationTypeNames.XmlDocCommentDelimiter); } else if (SyntaxFacts.IsPreprocessorDirective(trivia.Kind())) { ClassifyPreprocessorDirective((DirectiveTriviaSyntax)trivia.GetStructure()); } }
public bool TriviaStructure(SyntaxTrivia trivia, SyntaxTree tree, ref string errorText) { var retVal = true; if (trivia.HasStructure) { if (trivia.GetStructure() == null) { retVal = false; errorText = "This structured trivia has null structure"; } else if (!trivia.GetStructure().IsStructuredTrivia) { retVal = false; errorText = "This structured trivia's structure has IsStructuredTrivia set to 'False'"; } } else if (!trivia.HasStructure & trivia.GetStructure() != null) { retVal = false; errorText = "This non-structured trivia has non-null structure"; } return(retVal); }
private void ClassifyTrivia(SyntaxTrivia trivia, SyntaxTriviaList triviaList) { switch (trivia.Kind()) { case SyntaxKind.SingleLineCommentTrivia: case SyntaxKind.MultiLineCommentTrivia: case SyntaxKind.ShebangDirectiveTrivia: AddClassification(trivia, ClassificationTypeNames.Comment); return; case SyntaxKind.DisabledTextTrivia: ClassifyDisabledText(trivia, triviaList); return; case SyntaxKind.SkippedTokensTrivia: ClassifySkippedTokens((SkippedTokensTriviaSyntax)trivia.GetStructure() !); return; case SyntaxKind.SingleLineDocumentationCommentTrivia: case SyntaxKind.MultiLineDocumentationCommentTrivia: ClassifyDocumentationComment( (DocumentationCommentTriviaSyntax)trivia.GetStructure() ! ); return; case SyntaxKind.DocumentationCommentExteriorTrivia: AddClassification(trivia, ClassificationTypeNames.XmlDocCommentDelimiter); return; case SyntaxKind.ConflictMarkerTrivia: ClassifyConflictMarker(trivia); return; case SyntaxKind.IfDirectiveTrivia: case SyntaxKind.ElifDirectiveTrivia: case SyntaxKind.ElseDirectiveTrivia: case SyntaxKind.EndIfDirectiveTrivia: case SyntaxKind.RegionDirectiveTrivia: case SyntaxKind.EndRegionDirectiveTrivia: case SyntaxKind.DefineDirectiveTrivia: case SyntaxKind.UndefDirectiveTrivia: case SyntaxKind.ErrorDirectiveTrivia: case SyntaxKind.WarningDirectiveTrivia: case SyntaxKind.LineDirectiveTrivia: case SyntaxKind.PragmaWarningDirectiveTrivia: case SyntaxKind.PragmaChecksumDirectiveTrivia: case SyntaxKind.ReferenceDirectiveTrivia: case SyntaxKind.LoadDirectiveTrivia: case SyntaxKind.NullableDirectiveTrivia: case SyntaxKind.BadDirectiveTrivia: ClassifyPreprocessorDirective((DirectiveTriviaSyntax)trivia.GetStructure() !); return; } }
public StructuredTrivia(SyntaxTrivia trivia, int initialColumn) : base(trivia.GetStructure()) { Contract.ThrowIfFalse(trivia.HasStructure); _trivia = trivia; var root = trivia.GetStructure(); var text = GetText(); _initialColumn = initialColumn; _treeData = (text == null) ? (TreeData)new Node(root) : new NodeAndText(root, text); }
public StructuredTrivia(SyntaxTrivia trivia, int initialColumn) : base(trivia.GetStructure() !) { Contract.ThrowIfFalse(trivia.HasStructure); _trivia = trivia; var root = trivia.GetStructure() !; var text = GetText(); _initialColumn = initialColumn; _treeData = (text == null) ? (TreeData) new Node(root) : new NodeAndText(root, text); }
private static bool ContainsInterleavedDirective( TextSpan textSpan, SyntaxTrivia trivia, ref SimpleIntervalTree <TextSpan> ifEndIfSpans, CancellationToken cancellationToken) { if (trivia.HasStructure) { var parentSpan = trivia.GetStructure().Span; if (trivia.GetStructure().IsKind(SyntaxKind.RegionDirectiveTrivia) || trivia.GetStructure().IsKind(SyntaxKind.EndRegionDirectiveTrivia) || trivia.GetStructure().IsKind(SyntaxKind.IfDirectiveTrivia) || trivia.GetStructure().IsKind(SyntaxKind.EndIfDirectiveTrivia)) { var match = ((DirectiveTriviaSyntax)trivia.GetStructure()).GetMatchingDirective(cancellationToken); if (match != null) { var matchSpan = match.Span; if (!textSpan.Contains(matchSpan.Start)) { // The match for this pp directive is outside // this node. return(true); } if (trivia.GetStructure().IsKind(SyntaxKind.IfDirectiveTrivia) || trivia.GetStructure().IsKind(SyntaxKind.EndIfDirectiveTrivia)) { var ppSpan = TextSpan.FromBounds( Math.Min(parentSpan.Start, matchSpan.Start), Math.Max(parentSpan.End, matchSpan.End)); ifEndIfSpans = ifEndIfSpans.AddInterval(ppSpan); } } } else if ( trivia.GetStructure().IsKind(SyntaxKind.ElseDirectiveTrivia) || trivia.GetStructure().IsKind(SyntaxKind.ElifDirectiveTrivia)) { if (!ifEndIfSpans.IntersectsWith(parentSpan.Start)) { // This else/elif belongs to a pp span that isn't // entirely within this node. return(true); } } } return(false); }
/// <summary> /// Возвращает структуру комментария. /// </summary> /// <param name="ownerName">Имя владельца комментария.</param> public void GetCommentsStructure(string ownerName) { var xmlList = XmlСomment.GetStructure().ChildNodes().ToList(); foreach (var xmlElement in xmlList) { if (xmlElement.Kind() is SyntaxKind.XmlText) { Comments.Add(new CommentStructure(xmlElement)); continue; } var xmlElementList = (XmlElementSyntax)xmlElement; var typeXml = xmlElementList.StartTag.Name.ToString(); switch (typeXml) { case "summary": Comments.Add(new CommentStructure(xmlElementList, ownerName, GetCommentText(xmlElementList))); break; case "param": Comments.Add(new CommentStructure(xmlElementList, AutoCommentRules.GenerateStandartAutoComment(GetParameterName(xmlElementList.StartTag)), GetCommentText(xmlElementList))); break; case "returns": Comments.Add(new CommentStructure(xmlElementList, AutoCommentRules.GenerateReturnAutoComment(), GetCommentText(xmlElementList))); break; } } }
public virtual void VisitTrivia(SyntaxTrivia trivia) { if (this.Depth >= SyntaxWalkerDepth.StructuredTrivia && trivia.HasStructure) { this.Visit((CSharpSyntaxNode)trivia.GetStructure()); } }
private void BufferTrivia(List <SyntaxTrivia> buffer, SyntaxTrivia trivia) { if (trivia.IsKind(SyntaxKind.WhitespaceTrivia)) { return; // skip whitespace } if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) { // swap out \r\n for \n to simplify line measurements later buffer.Add(SyntaxFactory.LineFeed); } if (trivia.HasStructure) { // break out structured trivia var node = (StructuredTriviaSyntax)trivia.GetStructure(); foreach (var leading in node.GetLeadingTrivia()) { buffer.Add(leading); } buffer.Add(SyntaxFactory.Trivia(node.WithLeadingTrivia(SyntaxTriviaList.Empty).WithTrailingTrivia(SyntaxTriviaList.Empty))); foreach (var trailing in node.GetTrailingTrivia()) { buffer.Add(trailing); } } }
public static void Analyze( SyntaxNodeAnalysisContext context, MemberDeclarationSyntax memberDeclaration, SeparatedSyntaxList <TypeParameterSyntax> typeParameters) { if (typeParameters.Any(f => !f.IsMissing)) { SyntaxTrivia trivia = memberDeclaration.GetSingleLineDocumentationComment(); if (trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia)) { var comment = trivia.GetStructure() as DocumentationCommentTriviaSyntax; if (comment?.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) == true) { var names = new HashSet <string>(DocumentationCommentRefactoring.GetNameAttributeValues(comment, "typeparam")); foreach (TypeParameterSyntax typeParameter in typeParameters) { if (!typeParameter.IsMissing && !names.Contains(typeParameter.Identifier.ValueText)) { context.ReportDiagnostic( DiagnosticDescriptors.AddTypeParameterToDocumentationComment, typeParameter); } } } } } }
private static ThrowInfo GetUndocumentedExceptionInfo( SyntaxNode node, ExpressionSyntax expression, MemberDeclarationSyntax declaration, ISymbol declarationSymbol, SemanticModel semanticModel, CancellationToken cancellationToken) { if (expression != null) { ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, cancellationToken); if (typeSymbol?.IsErrorType() == false && SymbolUtility.IsException(typeSymbol, semanticModel)) { SyntaxTrivia trivia = declaration.GetSingleLineDocumentationComment(); if (trivia.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia)) { var comment = trivia.GetStructure() as DocumentationCommentTriviaSyntax; if (comment?.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) == true && !ContainsException(comment, typeSymbol, semanticModel, cancellationToken)) { return(ThrowInfo.Create(node, typeSymbol, declarationSymbol)); } } } } return(null); }
private static XmlNameAttributeSyntax ParseNameAttribute( string attributeText, string elementName ) { // NOTE: Rather than introducing a new code path that will have to be kept in // sync with other mode changes distributed throughout Lexer, SyntaxParser, and // DocumentationCommentParser, we'll just wrap the text in some lexable syntax // and then extract the piece we want. string commentText = string.Format(@"/// <{0} {1}/>", elementName, attributeText); SyntaxTriviaList leadingTrivia = SyntaxFactory.ParseLeadingTrivia( commentText, CSharpParseOptions.Default.WithDocumentationMode(DocumentationMode.Diagnose) ); Debug.Assert(leadingTrivia.Count == 1); SyntaxTrivia trivia = leadingTrivia.ElementAt(0); DocumentationCommentTriviaSyntax structure = (DocumentationCommentTriviaSyntax)trivia.GetStructure(); Debug.Assert(structure.Content.Count == 2); XmlEmptyElementSyntax elementSyntax = (XmlEmptyElementSyntax)structure.Content[1]; Debug.Assert(elementSyntax.Attributes.Count == 1); return((XmlNameAttributeSyntax)elementSyntax.Attributes[0]); }
private string ParseDocumentationCommentTrivia(SyntaxTrivia syntax) { var elements = syntax .GetStructure() ?.DescendantNodes() .Where(t => t.Kind() == SyntaxKind.XmlElement) .OfType <XmlElementSyntax>() .ToArray(); var e = elements ?.FirstOrDefault(t => t.StartTag.Name.LocalName.Text == "summary"); if (e == null) { return(""); } var texts = e.Content.OfType <XmlTextSyntax>() .Select(t => t.TextTokens) .SelectMany(u => u) .Select(t => t.Text) .JoinToString(""); var comments = texts .Trim() .Split('\n') .Select(s => s.Trim()) .Select(s => " * " + s) .JoinToString("\n"); return("/**\n" + comments + "\n */"); }
/// <summary> /// if the given trivia is the very first or the last trivia between two normal tokens and /// if the trivia is structured trivia, get one token that belongs to the structured trivia and one belongs to the normal token stream /// </summary> private void GetTokensAtEdgeOfStructureTrivia(SyntaxTrivia trivia1, SyntaxTrivia trivia2, out SyntaxToken token1, out SyntaxToken token2) { token1 = default(SyntaxToken); if (trivia1.RawKind == 0) { token1 = this.Token1; } else if (trivia1.HasStructure) { var lastToken = trivia1.GetStructure().GetLastToken(includeZeroWidth: true); if (ContainsOnlyWhitespace(lastToken.Span.End, lastToken.FullSpan.End)) { token1 = lastToken; } } token2 = default(SyntaxToken); if (trivia2.RawKind == 0) { token2 = this.Token2; } else if (trivia2.HasStructure) { var firstToken = trivia2.GetStructure().GetFirstToken(includeZeroWidth: true); if (ContainsOnlyWhitespace(firstToken.FullSpan.Start, firstToken.SpanStart)) { token2 = firstToken; } } }
/// <summary> /// Called when the walker visits a trivia. /// </summary> /// <param name="trivia"></param> public virtual void VisitTrivia(SyntaxTrivia trivia) { if (Depth >= SyntaxWalkerDepth.StructuredTrivia && trivia.HasStructure) { Visit((LuaSyntaxNode)trivia.GetStructure() !); } }
private IDom CreateEndRegion(SyntaxTrivia trivia, IDom parent, OutputContext context) { if (!trivia.HasStructure) { return(null); } var structure = trivia.GetStructure(); var regionSyntax = structure as EndRegionDirectiveTriviaSyntax; var startDirectives = regionSyntax .GetRelatedDirectives() .Where(x => x is RegionDirectiveTriviaSyntax); if (startDirectives.Count() != 1) { throw new NotImplementedException(); } var startSyntax = startDirectives.Single(); var container = parent as IContainer; if (container == null) { throw new NotImplementedException(); } var startBlock = container.GetMembers() .OfType <RDomDetailBlockStart>() .Where(x => MatchEndRegion(startSyntax, x.TypedTrivia)) .SingleOrDefault(); var newItem = new RDomDetailBlockEnd(parent, trivia, startBlock); if (trivia.Token.LeadingTrivia.Any()) { newItem.Whitespace2Set.Add(GetWhitespace(trivia.Token.LeadingTrivia.First())); } return(newItem); }
private DocumentationComment Translate(SyntaxTrivia trivia) { var comment = new DocumentationComment() { Params = new List <DocumentationParam>() }; var xmlElements = trivia.GetStructure()?.ChildNodes().OfType <XmlElementSyntax>(); foreach (var xmlElement in xmlElements) { switch (xmlElement.StartTag.Name.ToString()) { case XmlCommentTags.Summary: comment.Summary = GetContent(xmlElement); break; case XmlCommentTags.Parameter: var paramInfo = new DocumentationParam(); var nameAttribute = xmlElement.StartTag.ChildNodes().FirstOrDefault(_ => _ is XmlNameAttributeSyntax); paramInfo.ArgumentName = ((IdentifierNameSyntax)nameAttribute?.ChildNodes().FirstOrDefault(_ => _ is IdentifierNameSyntax))?.Identifier.ValueText; paramInfo.ArgumentComment = GetContent(xmlElement); comment.Params.Add(paramInfo); break; } } return(comment); }
private bool ValidateTrivia(SyntaxTrivia trivia, SyntaxTree tree, string filename = "", List <Failure> failures = null) { var retVal = true; if (trivia.HasStructure) { retVal = retVal & ValidateNonTerminal(trivia.GetStructure(), tree, filename, failures); } bool pass = false; foreach (var rule in _triviaRules.Values) { var errorText = string.Empty; pass = rule.Test(trivia, tree, ref errorText); if (!pass) { if (failures != null) { failures.Add(new Failure(filename, rule, trivia.GetKind(), errorText, new FailureLocation(trivia.Span, tree))); } ValidationFailed(errorText, rule); } retVal = retVal & pass; } return(retVal); }
private static bool EndsInLineBreak(SyntaxTrivia trivia) { if (trivia.Kind() == SyntaxKind.EndOfLineTrivia) { return(true); } if (trivia.Kind() == SyntaxKind.PreprocessingMessageTrivia || trivia.Kind() == SyntaxKind.DisabledTextTrivia) { var text = trivia.ToFullString(); return(text.Length > 0 && SyntaxFacts.IsNewLine(text.Last())); } if (trivia.HasStructure) { var node = trivia.GetStructure(); var trailing = node.GetTrailingTrivia(); if (trailing.Count > 0) { return(EndsInLineBreak(trailing.Last())); } else { return(IsLineBreak(node.GetLastToken())); } } return(false); }
private static EndRegionDirectiveTriviaSyntax FindEndRegion(SyntaxTriviaList list, int index) { for (int i = index + 1; i < list.Count; i++) { SyntaxTrivia trivia = list[i]; switch (trivia.Kind()) { case SyntaxKind.WhitespaceTrivia: case SyntaxKind.EndOfLineTrivia: { continue; } case SyntaxKind.EndRegionDirectiveTrivia: { if (trivia.HasStructure) { return((EndRegionDirectiveTriviaSyntax)trivia.GetStructure()); } return(null); } default: { return(null); } } } return(null); }
private void ProcessTrivia(SyntaxTrivia trivia) { if (trivia.HasStructure && trivia.FullSpan.IntersectsWith(_textSpan)) { Recurse(trivia.GetStructure() !); } }
public async Task <Document> RefactorAsync( Document document, DocumentationCommentTriviaSyntax comment, CancellationToken cancellationToken = default(CancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); MemberDeclarationSyntax memberDeclaration = comment.FirstAncestor <MemberDeclarationSyntax>(); SeparatedSyntaxList <TNode> typeParameters = GetSyntaxList(memberDeclaration); List <ElementInfo <TNode> > infos = GetElementInfos(comment, typeParameters); string newTrivia = GetNewTrivia(comment, infos); SyntaxTriviaList triviaList = SyntaxFactory.ParseLeadingTrivia(newTrivia); if (triviaList.Any()) { SyntaxTrivia firstTrivia = triviaList.First(); if (firstTrivia.HasStructure && (firstTrivia.GetStructure() is DocumentationCommentTriviaSyntax newComment)) { newComment = newComment.WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(comment, newComment, cancellationToken).ConfigureAwait(false)); } } Debug.Fail(""); return(document); }
public override void VisitTrivia(SyntaxTrivia trivia) { if (trivia.HasStructure) { Visit(trivia.GetStructure()); } switch (trivia.CSharpKind()) { case SyntaxKind.MultiLineCommentTrivia: case SyntaxKind.SingleLineCommentTrivia: case SyntaxKind.SingleLineDocumentationCommentTrivia: case SyntaxKind.MultiLineDocumentationCommentTrivia: case SyntaxKind.DocumentationCommentExteriorTrivia: Mark(trivia, "comment"); break; case SyntaxKind.EndOfLineTrivia: case SyntaxKind.WhitespaceTrivia: Mark(trivia, "whitespace"); break; case SyntaxKind.RegionDirectiveTrivia: Mark(trivia, "begin-region"); break; case SyntaxKind.EndRegionDirectiveTrivia: Mark(trivia, "end-region"); break; case SyntaxKind.DisabledTextTrivia: Mark(trivia, "disabled-text"); break; } }
private static SyntaxTrivia ConvertDocumentationComment(SyntaxTrivia trivia, CSharpSyntaxRewriter rewriter) { var structure = trivia.GetStructure(); var updatedStructure = (StructuredTriviaSyntax)rewriter.Visit(structure); return(SyntaxFactory.Trivia(updatedStructure)); }
/// <summary> /// Finds a token according to the following rules: /// 1) If position matches the End of the node/s FullSpan and the node is CompilationUnit, /// then EoF is returned. /// /// 2) If node.FullSpan.Contains(position) then the token that contains given position is /// returned. /// /// 3) Otherwise an ArgumentOutOfRangeException is thrown /// </summary> internal SyntaxToken FindTokenIncludingCrefAndNameAttributes(int position) { SyntaxToken nonTriviaToken = this.FindToken(position, findInsideTrivia: false); SyntaxTrivia trivia = GetTriviaFromSyntaxToken(position, nonTriviaToken); if (!SyntaxFacts.IsDocumentationCommentTrivia(trivia.Kind())) { return(nonTriviaToken); } Debug.Assert(trivia.HasStructure); SyntaxToken triviaToken = ((CSharpSyntaxNode)trivia.GetStructure()).FindTokenInternal(position); // CONSIDER: We might want to use the trivia token anywhere within a doc comment. // Otherwise, we'll fall back on the enclosing scope outside of name and cref // attribute values. CSharpSyntaxNode curr = (CSharpSyntaxNode)triviaToken.Parent; while (curr != null) { // Don't return a trivia token unless we're in the scope of a cref or name attribute. if (curr.Kind() == SyntaxKind.XmlCrefAttribute || curr.Kind() == SyntaxKind.XmlNameAttribute) { return(LookupPosition.IsInXmlAttributeValue(position, (XmlAttributeSyntax)curr) ? triviaToken : nonTriviaToken); } curr = curr.Parent; } return(nonTriviaToken); }
internal IDom CreateEndRegion(SyntaxTrivia trivia, IDom parent, OutputContext context) { if (!trivia.HasStructure) { return(null); } var structure = trivia.GetStructure(); var regionSyntax = structure as EndRegionDirectiveTriviaSyntax; //var startDirectives = regionSyntax // .GetRelatedDirectives() // .Where(x => x is RegionDirectiveTriviaSyntax); //if (startDirectives.Count() != 1) { throw new NotImplementedException(); } //var startSyntax = startDirectives.Single(); //var startIDom = parent.DescendantsAndSelf // .Where(x => (x.RawItem as SyntaxNode) != null // && x.RawItem == startSyntax) // .OfType<IDetailBlockStart>() // .First(); //if (startIDom == null) throw new NotImplementedException(); //var newItem = new RDomDetailBlockEnd(parent, trivia, startIDom, regionSyntax); var newItem = new RDomDetailBlockEnd(parent, trivia, null, regionSyntax); if (trivia.Token.LeadingTrivia.Any()) { newItem.Whitespace2Set.Add(GetWhitespace(trivia.Token.LeadingTrivia.First())); } //var newParent = startIDom.Parent as IContainer; //newParent.AddOrMoveMember(newItem); //return null; return(newItem); }
private static bool ShouldFormatSingleLineDocumentationComment(int indentation, int tabSize, SyntaxTrivia trivia) { var xmlComment = (DocumentationCommentTriviaSyntax)trivia.GetStructure(); var sawFirstOne = false; foreach (var token in xmlComment.DescendantTokens()) { foreach (var xmlTrivia in token.LeadingTrivia) { if (xmlTrivia.Kind() == SyntaxKind.DocumentationCommentExteriorTrivia) { // skip first one since its leading whitespace will belong to syntax tree's syntax token // not xml doc comment's token if (!sawFirstOne) { sawFirstOne = true; break; } var xmlCommentText = xmlTrivia.ToString(); // "///" == 3. if (xmlCommentText.GetColumnFromLineOffset(xmlCommentText.Length - 3, tabSize) != indentation) { return(true); } break; } } } return(false); }
public async Task <Document> RefactorAsync( Document document, TNode node, CancellationToken cancellationToken) { MemberDeclarationSyntax memberDeclaration = GetMemberDeclaration(node); DocumentationCommentTriviaSyntax comment = memberDeclaration.GetSingleLineDocumentationComment(); SeparatedSyntaxList <TNode> typeParameters = GetContainingList(node); List <ElementInfo <TNode> > infos = GetElementInfos(comment, typeParameters); string newTrivia = GetNewTrivia(comment, infos); SyntaxTriviaList triviaList = SyntaxFactory.ParseLeadingTrivia(newTrivia); if (triviaList.Any()) { SyntaxTrivia firstTrivia = triviaList.First(); if (firstTrivia.HasStructure && (firstTrivia.GetStructure() is DocumentationCommentTriviaSyntax newComment)) { newComment = newComment.WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(comment, newComment, cancellationToken).ConfigureAwait(false)); } } Debug.Fail(""); return(document); }
private static string MapRegionName(SyntaxTrivia source) { const string defaultRegionName = "Region"; var syntaxNode = source.GetStructure(); var name = "#"; switch (LanguageHelper.GetLanguage(syntaxNode.Language)) { case LanguageEnum.CSharp: var endDirectiveToken = (syntaxNode as RegionDirectiveTriviaSyntax).EndOfDirectiveToken; if (endDirectiveToken.HasLeadingTrivia) { name += endDirectiveToken.LeadingTrivia.First().ToString(); } else { name += defaultRegionName; } break; case LanguageEnum.VisualBasic: name += (syntaxNode as VisualBasicSyntax.RegionDirectiveTriviaSyntax).Name.ValueText; break; default: name += defaultRegionName; break; } return(name); }
private static Task <Document> RefactorAsync( Document document, PragmaWarningDirectiveTriviaSyntax directive, CancellationToken cancellationToken) { SyntaxTrivia trivia = directive.ParentTrivia; SyntaxTriviaList list = trivia.GetContainingList(); int index = list.IndexOf(trivia); int start = directive.EndOfDirectiveToken.SpanStart; StringBuilder sb = StringBuilderCache.GetInstance(); int i = index + 1; SyntaxKind disableOrRestoreKind = directive.DisableOrRestoreKeyword.Kind(); int end = start; bool addComma = !directive.ErrorCodes.HasTrailingSeparator(); while (i < list.Count) { SyntaxTrivia trivia2 = list[i]; if (trivia2.IsWhitespaceOrEndOfLineTrivia()) { i++; continue; } if (trivia2.GetStructure() is PragmaWarningDirectiveTriviaSyntax directive2 && disableOrRestoreKind == directive2.DisableOrRestoreKeyword.Kind()) { if (addComma) { sb.Append(","); } sb.Append(" "); SeparatedSyntaxList <ExpressionSyntax> errorCodes = directive2.ErrorCodes; sb.Append(errorCodes.ToString()); addComma = !errorCodes.HasTrailingSeparator(); end = directive2.ErrorCodes.Span.End; } i++; } return(document.WithTextChangeAsync( TextSpan.FromBounds(start, end), StringBuilderCache.GetStringAndFree(sb), cancellationToken)); }
private static SyntaxTrivia ConvertDocumentationComment(SyntaxTrivia trivia, CSharpSyntaxRewriter rewriter) { var structure = trivia.GetStructure(); var rewritten = rewriter.Visit(structure); Contract.ThrowIfNull(rewritten); return(SyntaxFactory.Trivia((StructuredTriviaSyntax)rewritten)); }
public static IFormattingResult Format( SyntaxTrivia trivia, int initialColumn, OptionSet optionSet, ChainedFormattingRules formattingRules, CancellationToken cancellationToken) { var root = trivia.GetStructure(); var formatter = new CSharpStructuredTriviaFormatEngine(trivia, initialColumn, optionSet, formattingRules, root.GetFirstToken(includeZeroWidth: true), root.GetLastToken(includeZeroWidth: true)); return formatter.FormatAsync(cancellationToken).WaitAndGetResult_CanCallOnBackground(cancellationToken); }
private static void HandleDocumentationCommentTrivia(SyntaxTreeAnalysisContext context, SyntaxTrivia trivia) { foreach (var token in trivia.GetStructure().DescendantTokens(descendIntoTrivia: true)) { switch (token.Kind()) { case SyntaxKind.XmlTextLiteralToken: HandleWhitespaceToken(context, token); break; default: break; } } }
private static Location GetDiagnosticLocation(SyntaxTrivia documentationHeader) { var documentationHeaderStructure = (DocumentationCommentTriviaSyntax)documentationHeader.GetStructure(); return Location.Create(documentationHeaderStructure.SyntaxTree, documentationHeaderStructure.GetLeadingTrivia().Span); }
private static bool ShouldFormatSingleLineDocumentationComment(int indentation, int tabSize, SyntaxTrivia trivia) { var xmlComment = (DocumentationCommentTriviaSyntax)trivia.GetStructure(); var sawFirstOne = false; foreach (var token in xmlComment.DescendantTokens()) { foreach (var xmlTrivia in token.LeadingTrivia) { if (xmlTrivia.Kind() == SyntaxKind.DocumentationCommentExteriorTrivia) { // skip first one since its leading whitespace will belong to syntax tree's syntax token // not xml doc comment's token if (!sawFirstOne) { sawFirstOne = true; break; } var xmlCommentText = xmlTrivia.ToString(); // "///" == 3. if (xmlCommentText.GetColumnFromLineOffset(xmlCommentText.Length - 3, tabSize) != indentation) { return true; } break; } } } return false; }
protected override bool ContainsImplicitLineBreak(SyntaxTrivia trivia) { if (!trivia.HasStructure) { return false; } var structuredTrivia = trivia.GetStructure(); return structuredTrivia != null && structuredTrivia.HasTrailingTrivia && structuredTrivia.GetTrailingTrivia().Any(SyntaxKind.EndOfLineTrivia); }
private static bool IsEndOfLineOrContainsEndOfLine(SyntaxTrivia trivia, AbstractSuppressionCodeFixProvider fixer) { return fixer.IsEndOfLine(trivia) || (trivia.HasStructure && trivia.GetStructure().DescendantTrivia().Any(t => fixer.IsEndOfLine(t))); }
private static bool IsEndOfLineOrHasTrailingEndOfLine(SyntaxTrivia trivia, AbstractSuppressionCodeFixProvider fixer) { return fixer.IsEndOfLine(trivia) || (trivia.HasStructure && fixer.IsEndOfLine(trivia.GetStructure().DescendantTrivia().LastOrDefault())); }
private ApiCall QuoteTrivia(SyntaxTrivia syntaxTrivia) { string factoryMethodName = SyntaxFactoryMethod("Trivia"); string text = syntaxTrivia.ToString(); if (syntaxTrivia.FullSpan.Length == 0 || (syntaxTrivia.Kind() == SyntaxKind.WhitespaceTrivia && UseDefaultFormatting)) { return null; } PropertyInfo triviaFactoryProperty = null; if (triviaFactoryProperties.TryGetValue(syntaxTrivia.ToString(), out triviaFactoryProperty) && ((SyntaxTrivia)triviaFactoryProperty.GetValue(null)).Kind() == syntaxTrivia.Kind()) { if (UseDefaultFormatting) { return null; } return new ApiCall(null, SyntaxFactoryMethod(triviaFactoryProperty.Name)); } if (!string.IsNullOrEmpty(text) && string.IsNullOrWhiteSpace(text) && syntaxTrivia.Kind() == SyntaxKind.WhitespaceTrivia) { if (UseDefaultFormatting) { return null; } factoryMethodName = SyntaxFactoryMethod("Whitespace"); } if (syntaxTrivia.Kind() == SyntaxKind.SingleLineCommentTrivia || syntaxTrivia.Kind() == SyntaxKind.MultiLineCommentTrivia) { factoryMethodName = SyntaxFactoryMethod("Comment"); } if (syntaxTrivia.Kind() == SyntaxKind.PreprocessingMessageTrivia) { factoryMethodName = SyntaxFactoryMethod("PreprocessingMessage"); } if (syntaxTrivia.Kind() == SyntaxKind.DisabledTextTrivia) { factoryMethodName = SyntaxFactoryMethod("DisabledText"); } if (syntaxTrivia.Kind() == SyntaxKind.DocumentationCommentExteriorTrivia) { factoryMethodName = SyntaxFactoryMethod("DocumentationCommentExterior"); } var t = syntaxTrivia.ToString(); var verbatim = t.Contains("\r") || t.Contains("\n"); object argument = EscapeAndQuote(t, verbatim: verbatim); if (syntaxTrivia.HasStructure) { argument = QuoteNode(syntaxTrivia.GetStructure(), "Structure"); } return new ApiCall(null, factoryMethodName, CreateArgumentList(argument)); }
private bool TryGetLastTokenForStructuredTrivia( SyntaxTrivia trivia, Func<SyntaxToken, bool> predicate, Func<SyntaxTrivia, bool> stepInto, out SyntaxToken token) { token = default(SyntaxToken); if (!trivia.HasStructure || stepInto == null || !stepInto(trivia)) { return false; } token = GetLastToken(trivia.GetStructure(), predicate, stepInto); return token.RawKind != None; }
public bool TriviaStructure(SyntaxTrivia trivia, SyntaxTree tree, ref string errorText) { var retVal = true; if (trivia.HasStructure) { if (trivia.GetStructure() == null) { retVal = false; errorText = "This structured trivia has null structure"; } else if (!trivia.GetStructure().IsStructuredTrivia) { retVal = false; errorText = "This structured trivia's structure has IsStructuredTrivia set to 'False'"; } } else if (!trivia.HasStructure & trivia.GetStructure() != null) { retVal = false; errorText = "This non-structured trivia has non-null structure"; } return retVal; }
protected override SyntaxTrivia TogglePragmaDirective(SyntaxTrivia trivia) { var pragmaWarning = (PragmaWarningDirectiveTriviaSyntax)trivia.GetStructure(); var currentKeyword = pragmaWarning.DisableOrRestoreKeyword; var toggledKeywordKind = currentKeyword.Kind() == SyntaxKind.DisableKeyword ? SyntaxKind.RestoreKeyword : SyntaxKind.DisableKeyword; var toggledToken = SyntaxFactory.Token(currentKeyword.LeadingTrivia, toggledKeywordKind, currentKeyword.TrailingTrivia); var newPragmaWarning = pragmaWarning.WithDisableOrRestoreKeyword(toggledToken); return SyntaxFactory.Trivia(newPragmaWarning); }
public override void VisitTrivia(SyntaxTrivia trivia) { if (trivia.HasStructure) Visit(trivia.GetStructure()); switch (trivia.CSharpKind()) { case SyntaxKind.MultiLineCommentTrivia: case SyntaxKind.SingleLineCommentTrivia: case SyntaxKind.SingleLineDocumentationCommentTrivia: case SyntaxKind.MultiLineDocumentationCommentTrivia: case SyntaxKind.DocumentationCommentExteriorTrivia: Mark(trivia, "comment"); break; case SyntaxKind.EndOfLineTrivia: case SyntaxKind.WhitespaceTrivia: Mark(trivia, "whitespace"); break; case SyntaxKind.RegionDirectiveTrivia: Mark(trivia, "begin-region"); break; case SyntaxKind.EndRegionDirectiveTrivia: Mark(trivia, "end-region"); break; case SyntaxKind.DisabledTextTrivia: Mark(trivia, "disabled-text"); break; } }
private ApiCall QuoteTrivia(SyntaxTrivia syntaxTrivia) { string factoryMethodName = "SyntaxFactory.Trivia"; string text = syntaxTrivia.ToString(); if (syntaxTrivia.FullSpan.Length == 0 || (syntaxTrivia.Kind() == SyntaxKind.WhitespaceTrivia && UseDefaultFormatting)) { return null; } PropertyInfo triviaFactoryProperty = null; if (triviaFactoryProperties.TryGetValue(syntaxTrivia.ToString(), out triviaFactoryProperty) && ((SyntaxTrivia)triviaFactoryProperty.GetValue(null)).Kind() == syntaxTrivia.Kind()) { if (UseDefaultFormatting) { return null; } return new ApiCall(null, "SyntaxFactory." + triviaFactoryProperty.Name); } if (!string.IsNullOrEmpty(text) && string.IsNullOrWhiteSpace(text) && syntaxTrivia.Kind() == SyntaxKind.WhitespaceTrivia) { if (UseDefaultFormatting) { return null; } factoryMethodName = "SyntaxFactory.Whitespace"; } if (syntaxTrivia.Kind() == SyntaxKind.SingleLineCommentTrivia || syntaxTrivia.Kind() == SyntaxKind.MultiLineCommentTrivia) { factoryMethodName = "SyntaxFactory.Comment"; } if (syntaxTrivia.Kind() == SyntaxKind.PreprocessingMessageTrivia) { factoryMethodName = "SyntaxFactory.PreprocessingMessage"; } if (syntaxTrivia.Kind() == SyntaxKind.DisabledTextTrivia) { factoryMethodName = "SyntaxFactory.DisabledText"; } if (syntaxTrivia.Kind() == SyntaxKind.DocumentationCommentExteriorTrivia) { factoryMethodName = "SyntaxFactory.DocumentationCommentExterior"; } object argument = "@\"" + Escape(syntaxTrivia.ToString()) + "\""; if (syntaxTrivia.HasStructure) { argument = QuoteNode(syntaxTrivia.GetStructure(), "Structure"); } return new ApiCall(null, factoryMethodName, CreateArgumentList(argument)); }
public override void VisitTrivia(SyntaxTrivia trivia) { bool isDocComment = SyntaxFacts.IsDocumentationCommentTrivia(trivia.Kind()); if (isDocComment || trivia.Kind() == SyntaxKind.SingleLineCommentTrivia || trivia.Kind() == SyntaxKind.MultiLineCommentTrivia) { Results.AppendLine(); Results.Append(trivia.ToFullString().Trim()); Results.Append(" (Parent Token: "); Results.Append(trivia.Token.Kind()); Results.Append(")"); if (isDocComment) { // Trivia for xml documentation comments have additional 'structure' // available under a child DocumentationCommentSyntax. Assert.True(trivia.HasStructure); var documentationComment = (DocumentationCommentTriviaSyntax)trivia.GetStructure(); Assert.True(documentationComment.ParentTrivia == trivia); Results.Append(" (Structured)"); } } base.VisitTrivia(trivia); }
private void AddTrivia(TreeViewItem parentItem, SyntaxTrivia trivia, bool isLeadingTrivia) { var kind = trivia.GetKind(); var tag = new SyntaxTag() { SyntaxTrivia = trivia, Category = SyntaxCategory.SyntaxTrivia, Span = trivia.Span, FullSpan = trivia.FullSpan, Kind = kind, ParentItem = parentItem }; var item = new TreeViewItem() { Tag = tag, IsExpanded = false, Foreground = Brushes.Maroon, Background = trivia.ContainsDiagnostics ? Brushes.Pink : Brushes.White, Header = (isLeadingTrivia ? "Lead: " : "Trail: ") + tag.Kind + " " + trivia.Span.ToString() }; if (SyntaxTree != null && trivia.ContainsDiagnostics) { item.ToolTip = string.Empty; foreach (var diagnostic in SyntaxTree.GetDiagnostics(trivia)) { item.ToolTip += diagnostic.ToString() + "\n"; } item.ToolTip = item.ToolTip.ToString().Trim(); } item.Selected += new RoutedEventHandler((sender, e) => { _isNavigatingFromTreeToSource = true; typeTextLabel.Visibility = Visibility.Visible; kindTextLabel.Visibility = Visibility.Visible; typeValueLabel.Content = trivia.GetType().Name; kindValueLabel.Content = kind; _propertyGrid.SelectedObject = trivia; item.IsExpanded = true; if (!_isNavigatingFromSourceToTree && SyntaxTriviaNavigationToSourceRequested != null) { SyntaxTriviaNavigationToSourceRequested(trivia); } _isNavigatingFromTreeToSource = false; e.Handled = true; }); item.Expanded += new RoutedEventHandler((sender, e) => { if (item.Items.Count == 1 && item.Items[0] == null) { // Remove placeholder child and populate real children. item.Items.RemoveAt(0); AddNode(item, trivia.GetStructure()); } }); if (parentItem == null) { treeView.Items.Clear(); treeView.Items.Add(item); typeTextLabel.Visibility = Visibility.Hidden; kindTextLabel.Visibility = Visibility.Hidden; typeValueLabel.Content = string.Empty; kindValueLabel.Content = string.Empty; } else { parentItem.Items.Add(item); } if (trivia.HasStructure) { if (IsLazy) { // Add placeholder child to indicate that real children need to be populated on expansion. item.Items.Add(null); } else { // Recursively populate all descendants. AddNode(item, trivia.GetStructure()); } } }
private bool ValidateTrivia(SyntaxTrivia trivia, SyntaxTree tree, string filename = "", List<Failure> failures = null) { var retVal = true; if (trivia.HasStructure) { retVal = retVal & ValidateNonTerminal(trivia.GetStructure(), tree, filename, failures); } bool pass = false; foreach (var rule in m_TriviaRules.Values) { var errorText = string.Empty; pass = rule.Test(trivia, tree, ref errorText); if (!pass) { if (failures != null) { failures.Add(new Failure(filename, rule, trivia.GetKind(), errorText, new FailureLocation(trivia.Span, tree))); } ValidationFailed(errorText, rule); } retVal = retVal & pass; } return retVal; }
private void TestShebang(SyntaxTrivia trivia, string expectedSkippedText) { Assert.True(trivia.IsDirective); Assert.Equal(SyntaxKind.ShebangDirectiveTrivia, trivia.Kind()); Assert.True(trivia.HasStructure); TestShebang((ShebangDirectiveTriviaSyntax)trivia.GetStructure(), expectedSkippedText); }
protected override bool IsAnyPragmaDirectiveForId(SyntaxTrivia trivia, string id, out bool enableDirective, out bool hasMultipleIds) { if (trivia.Kind() == SyntaxKind.PragmaWarningDirectiveTrivia) { var pragmaWarning = (PragmaWarningDirectiveTriviaSyntax)trivia.GetStructure(); enableDirective = pragmaWarning.DisableOrRestoreKeyword.Kind() == SyntaxKind.RestoreKeyword; hasMultipleIds = pragmaWarning.ErrorCodes.Count > 1; return pragmaWarning.ErrorCodes.Any(n => n.ToString() == id); } enableDirective = false; hasMultipleIds = false; return false; }
/// <summary> /// Called when the walker visits a trivia syntax. This method may be overridden if /// subclasses want to handle the token. Overrides should call back into this base method if /// they want the children of this trivia syntax to be visited. /// </summary> /// <param name="trivia">The current trivia syntax that the walker is visiting.</param> protected virtual void VisitTrivia(SyntaxTrivia trivia) { if (this.Depth >= SyntaxWalkerDepth.StructuredTrivia && trivia.HasStructure) { this.Visit(trivia.GetStructure()); } }