private static string[] GetCommentParts(PropertyDeclarationSyntax property)
{
var isArrowGetterOnly = property.ChildNodes().OfType <ArrowExpressionClauseSyntax>().Any();
if (isArrowGetterOnly)
{
return(GetOnly);
}
// try to find a getter
var getter = (AccessorDeclarationSyntax)property.AccessorList?.ChildNodes().FirstOrDefault(_ => _.IsKind(SyntaxKind.GetAccessorDeclaration));
if (getter is null || getter.Modifiers.Any(_ => _.IsKind(SyntaxKind.PrivateKeyword)))
{
return(SetOnly);
}
var setter = (AccessorDeclarationSyntax)property.AccessorList?.ChildNodes().FirstOrDefault(_ => _.IsKind(SyntaxKind.SetAccessorDeclaration));
if (setter is null || setter.Modifiers.Any(_ => _.IsKind(SyntaxKind.PrivateKeyword)))
{
return(GetOnly);
}
return(GetSet);
}
public override SyntaxNode VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
var arrowExpressionClause = node.ChildNodes().SingleOrDefault(x => x.Kind() == SyntaxKind.ArrowExpressionClause) as ArrowExpressionClauseSyntax;
if (arrowExpressionClause == null)
{
return(base.VisitPropertyDeclaration(node));
}
SyntaxToken identifierToken = node.ChildTokens().SingleOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken);
if (identifierToken.Kind() != SyntaxKind.IdentifierToken)
{
return(base.VisitPropertyDeclaration(node));
}
string arrowLeadingTrivia = arrowExpressionClause.GetLeadingTrivia().ToString();
string identifierTrailingTrivia = identifierToken.TrailingTrivia.ToString();
if (!ShouldFormat(arrowExpressionClause, identifierToken))
{
return(base.VisitPropertyDeclaration(node));
}
SyntaxNode newNode = FormatPropertyNode(node, identifierToken, arrowExpressionClause);
string newNodeString = newNode.ToString();
return(base.VisitPropertyDeclaration(newNode as PropertyDeclarationSyntax));
}
public override void VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
var trivia = node.HasLeadingTrivia
? node.GetLeadingTrivia()
: default(SyntaxTriviaList);
if (node.ShouldBeHidden(trivia))
{
return;
}
// multiline comment on property
AddMultiLineDocumentationComment(trivia);
// allow derived types to determine if this method should be json serialized
if (SerializePropertyDeclarationToJson(node))
{
return;
}
var memberName = node.Identifier.Text;
// decide whether we should strip the modifier/accessor and return type, based on if
// this is a property on the top level class
if (ClassDepth == 1)
{
var arrowExpressionClauseSyntax =
node.ChildNodes().OfType <ArrowExpressionClauseSyntax>().FirstOrDefault();
if (arrowExpressionClauseSyntax != null)
{
var firstChildNode = arrowExpressionClauseSyntax.ChildNodes().First();
Blocks.Add(new CSharpBlock(firstChildNode, ClassDepth, memberName));
}
else
{
// property getter
var blockNode = node.DescendantNodes().OfType <BlockSyntax>().FirstOrDefault();
if (blockNode != null)
{
AddBlockChildNodes(blockNode, memberName);
}
}
}
else
{
// assume this is a nested class' property
Blocks.Add(new CSharpBlock(node, ClassDepth, memberName));
}
if (node.HasTrailingTrivia)
{
trivia = node.GetTrailingTrivia();
AddMultiLineDocumentationComment(trivia);
}
}
public override void VisitPropertyDeclaration(PropertyDeclarationSyntax node)
{
var startLength = node.Span.Start;
var endLength = node.Span.End;
var parentNamespace = GetNamespace(DefineKinds.Property, startLength, endLength);
var defineType = node.ChildNodes().FirstOrDefault().ToString();
var defineName = node.ChildTokens().FirstOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken).ToString();
UserDefinitions.Add(new UserDefinition
{
DefineKinds = DefineKinds.Property,
Namespace = parentNamespace,
DefineName = defineName,
DefineFullName = $"{parentNamespace}.{defineName}",
ReturnType = RemoveNamespace(defineType),
SourceFile = SourceFile,
StartLength = startLength,
EndLength = endLength,
});
base.VisitPropertyDeclaration(node);
}
/// <summary>
/// Get summary.
/// </summary>
/// <param name="theSyntaxNode">The syntax node to add the summary.</param>
/// <returns>The syntax list.</returns>
private static DocumentationCommentTriviaSyntax GetSummary(PropertyDeclarationSyntax theSyntaxNode)
{
var summaryStart = XmlElementStartTag(XmlName(Identifier(Constants.Summary)))
.WithLessThanToken(Token(SyntaxKind.LessThanToken))
.WithGreaterThanToken(Token(SyntaxKind.GreaterThanToken)).NormalizeWhitespace();
var summaryEnd = XmlElementEndTag(XmlName(Identifier(Constants.Summary))).NormalizeWhitespace()
.WithLessThanSlashToken(Token(SyntaxKind.LessThanSlashToken))
.WithGreaterThanToken(Token(SyntaxKind.GreaterThanToken));
var hasGetter = false;
var hasSetter = false;
if (theSyntaxNode.AccessorList == null)
{
if (theSyntaxNode.ChildNodes().OfType <ArrowExpressionClauseSyntax>().Any())
{
hasGetter = true;
}
}
else
{
var accessors = theSyntaxNode.AccessorList.ChildNodes().OfType <AccessorDeclarationSyntax>();
foreach (var accessor in accessors)
{
if (accessor.Kind() == SyntaxKind.GetAccessorDeclaration)
{
if (!accessor.Modifiers.Any(SyntaxKind.PrivateKeyword))
{
hasGetter = true;
}
continue;
}
if (accessor.Kind() == SyntaxKind.SetAccessorDeclaration)
{
if (!accessor.Modifiers.Any(SyntaxKind.PrivateKeyword))
{
hasSetter = true;
}
}
}
}
var isBool = (theSyntaxNode.Type as PredefinedTypeSyntax)?.Keyword.Kind() == SyntaxKind.BoolKeyword;
var summaryComment = " " + Convert.Property(theSyntaxNode.Identifier.ValueText, hasGetter, hasSetter, isBool);
var summaryText = SingletonList <XmlNodeSyntax>(
XmlText().NormalizeWhitespace()
.WithTextTokens(
TokenList(
XmlTextNewLine(TriviaList(), Environment.NewLine, Environment.NewLine, TriviaList()).NormalizeWhitespace(),
XmlTextLiteral(
TriviaList(DocumentationCommentExterior("///")),
summaryComment,
summaryComment,
TriviaList()).NormalizeWhitespace(),
XmlTextNewLine(TriviaList(), Environment.NewLine, Environment.NewLine, TriviaList()).NormalizeWhitespace(),
XmlTextLiteral(
TriviaList(DocumentationCommentExterior("///")),
" ",
" ",
TriviaList()))).NormalizeWhitespace());
var xmlComment = XmlText()
.WithTextTokens(
TokenList(
XmlTextLiteral(
TriviaList(DocumentationCommentExterior("///")),
" ",
" ",
TriviaList()))).NormalizeWhitespace();
var newLine = XmlText().WithTextTokens(TokenList(XmlTextNewLine(TriviaList(), Environment.NewLine, Environment.NewLine, TriviaList()))).NormalizeWhitespace();
var summaryElement = XmlElement(summaryStart, summaryEnd).WithContent(summaryText);
var list = List(new XmlNodeSyntax[] { xmlComment, summaryElement, newLine });
// Add exceptions comments
var throws = theSyntaxNode.DescendantNodes().OfType <ThrowStatementSyntax>();
foreach (var syntax in throws)
{
if (syntax.ChildNodes().OfType <ObjectCreationExpressionSyntax>().Any())
{
var identifier = syntax.DescendantNodes().OfType <IdentifierNameSyntax>().FirstOrDefault();
var argumentList = syntax.DescendantNodes().OfType <ArgumentListSyntax>().FirstOrDefault();
var parms = argumentList.DescendantTokens().Where(x => x.IsKind(SyntaxKind.StringLiteralToken)).ToList();
var parmText = string.Empty;
if (parms.Any())
{
parmText = parms.Last().ValueText;
}
list = list.AddRange(
List(
new XmlNodeSyntax[]
{
xmlComment,
XmlElement(
XmlElementStartTag(XmlName(Identifier("exception")))
.WithAttributes(
SingletonList <XmlAttributeSyntax>(
XmlNameAttribute(
XmlName(Identifier(TriviaList(Space), "cref", TriviaList())),
Token(SyntaxKind.DoubleQuoteToken),
IdentifierName(identifier.Identifier.ValueText),
Token(SyntaxKind.DoubleQuoteToken)))),
XmlElementEndTag(XmlName(Identifier("exception"))))
.WithContent(
SingletonList <XmlNodeSyntax>(
XmlText()
.WithTextTokens(
TokenList(
XmlTextLiteral(
TriviaList(),
parmText,
"comment",
TriviaList()))))),
newLine
}));
}
}
return(DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, list));
}
private static AttributeSyntax GetIgnoreDataMemberAttribute(PropertyDeclarationSyntax property)
{
return(property.ChildNodes().OfType <AttributeListSyntax>().SelectMany(al => al.Attributes).FirstOrDefault(a => a.Name.ToString() == IgnoreDataMember));
}
