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 virtual void VisitTrivia(SyntaxTrivia trivia)
{
if (this.Depth >= SyntaxWalkerDepth.StructuredTrivia && trivia.HasStructure)
{
this.Visit((CSharpSyntaxNode)trivia.GetStructure());
}
}
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 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());
}
}
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());
}
}
