/// <summary>
/// From a FieldDeclarationSyntax, returns the field name.
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static String FieldName(this FieldDeclarationSyntax field)
{
var vars = field.DescendantNodes().Where(i => i.IsKind(SyntaxKind.VariableDeclarator));
VariableDeclaratorSyntax varName = (VariableDeclaratorSyntax)vars.First();
return(varName.Identifier.ToString());
}
public void Then_result_should_be_VariableDeclaration_with_Identifier_Bla()
{
var variableDeclaratorSyntax =
_fieldDeclaration.DescendantNodes().OfType <VariableDeclaratorSyntax>().FirstOrDefault();
variableDeclaratorSyntax.Identifier.Text.Should().Be("Bla");
}
/// <summary>
/// Analyzes node.
/// </summary>
/// <param name="context">The context.</param>
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
FieldDeclarationSyntax node = context.Node as FieldDeclarationSyntax;
// Only const field.
if (!node.Modifiers.Any(SyntaxKind.ConstKeyword))
{
return;
}
if (Configuration.IsEnabledForPublicMembersOnly && PrivateMemberChecker.IsPrivateMember(node))
{
return;
}
DocumentationCommentTriviaSyntax commentTriviaSyntax = node
.GetLeadingTrivia()
.Select(o => o.GetStructure())
.OfType <DocumentationCommentTriviaSyntax>()
.FirstOrDefault();
if (commentTriviaSyntax != null && CommentHelper.HasComment(commentTriviaSyntax))
{
return;
}
VariableDeclaratorSyntax field = node.DescendantNodes().OfType <VariableDeclaratorSyntax>().First();
context.ReportDiagnostic(Diagnostic.Create(Rule, field.GetLocation()));
}
/// <summary>
/// Analyzes node.
/// </summary>
/// <param name="context">The context.</param>
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
FieldDeclarationSyntax node = context.Node as FieldDeclarationSyntax;
// Only const.
if (!node.Modifiers.Any(SyntaxKind.ConstKeyword))
{
return;
}
DocumentationCommentTriviaSyntax commentTriviaSyntax = node
.GetLeadingTrivia()
.Select(o => o.GetStructure())
.OfType <DocumentationCommentTriviaSyntax>()
.FirstOrDefault();
if (commentTriviaSyntax != null)
{
bool hasSummary = commentTriviaSyntax
.ChildNodes()
.OfType <XmlElementSyntax>()
.Any(o => o.StartTag.Name.ToString().Equals(DocumentationHeaderHelper.Summary));
if (hasSummary)
{
return;
}
}
VariableDeclaratorSyntax field = node.DescendantNodes().OfType <VariableDeclaratorSyntax>().First();
context.ReportDiagnostic(Diagnostic.Create(Rule, field.GetLocation()));
}
public static bool ImplementsInterface <T>(this FieldDeclarationSyntax field, SemanticModel semanticModel)
{
var variableDeclaration = field.DescendantNodes().OfType <VariableDeclarationSyntax>().First();
var variableType = semanticModel.GetTypeInfo(variableDeclaration.Type).Type;
return(variableType.ImplementsInterface <T>());
}
private Task <Document> AddConstructorAsync(Document document, SyntaxNode root, FieldDeclarationSyntax fieldDeclaration)
{
var variableDeclaration = fieldDeclaration.DescendantNodes().OfType <VariableDeclarationSyntax>().FirstOrDefault();
var variableDeclarator = variableDeclaration.DescendantNodes().OfType <VariableDeclaratorSyntax>().FirstOrDefault();
var fieldName = variableDeclarator.Identifier.ValueText;
var typeDeclaration = fieldDeclaration.GetParentTypeDeclaration();
var newConstructor = CreateEmptyConstructor(typeDeclaration.Identifier.ValueText);
var parameterName = nameGenerator.GetNewParameterName(newConstructor.ParameterList, fieldName);
newConstructor = newConstructor.WithParameterList(
ParameterList(
SingletonSeparatedList(
Parameter(Identifier(parameterName))
.WithType(variableDeclaration.Type))));
var assignment = newConstructor.ParameterList.Parameters.Any(p => p.Identifier.ValueText == fieldName)
? CreateThisAssignmentStatement(fieldName, parameterName)
: CreateAssignmentStatement(fieldName, parameterName);
newConstructor = newConstructor.WithBody(newConstructor.Body.AddStatements(assignment));
newConstructor = InitializeStructFields(fieldDeclaration, typeDeclaration, newConstructor);
var newRoot = root.InsertNodesAfter(FindInsertionPoint(fieldDeclaration), SingletonList(newConstructor));
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
}
/// <summary>
/// Get summary.
/// </summary>
/// <param name="theSyntaxNode">The syntax node to add the summary.</param>
/// <returns>The syntax list.</returns>
private static DocumentationCommentTriviaSyntax GetSummary(FieldDeclarationSyntax 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 summaryComment = string.Empty;
var field = theSyntaxNode.DescendantNodes().OfType <VariableDeclaratorSyntax>().FirstOrDefault();
if (field != null)
{
var hasConst = theSyntaxNode.Modifiers.Any(SyntaxKind.ConstKeyword);
var hasReadOnly = theSyntaxNode.Modifiers.Any(SyntaxKind.ReadOnlyKeyword);
var equals = field.DescendantNodes().OfType <EqualsValueClauseSyntax>().FirstOrDefault();
summaryComment = " " + Convert.Field(field.Identifier.ValueText, hasConst, hasReadOnly, equals);
}
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 });
return(DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, list));
}
/// <summary>
/// Adds documentation header async.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="root">The root.</param>
/// <param name="declarationSyntax">The declaration syntax.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A Document.</returns>
private async Task <Document> AddDocumentationHeaderAsync(Document document, SyntaxNode root, FieldDeclarationSyntax declarationSyntax, CancellationToken cancellationToken)
{
SyntaxTriviaList leadingTrivia = declarationSyntax.GetLeadingTrivia();
VariableDeclaratorSyntax field = declarationSyntax.DescendantNodes().OfType <VariableDeclaratorSyntax>().First();
string comment = CommentHelper.CreateFieldComment(field.Identifier.ValueText);
DocumentationCommentTriviaSyntax commentTrivia = await Task.Run(() => DocumentationHeaderHelper.CreateOnlySummaryDocumentationCommentTrivia(comment), cancellationToken);
SyntaxTriviaList newLeadingTrivia = leadingTrivia.Insert(leadingTrivia.Count - 1, SyntaxFactory.Trivia(commentTrivia));
FieldDeclarationSyntax newDeclaration = declarationSyntax.WithLeadingTrivia(newLeadingTrivia);
SyntaxNode newRoot = root.ReplaceNode(declarationSyntax, newDeclaration);
return(document.WithSyntaxRoot(newRoot));
}
private async Task <Document> InitializeFieldInConstructorsAsync(Document document, SyntaxNode root,
FieldDeclarationSyntax fieldDeclaration, IEnumerable <ConstructorDeclarationSyntax> constructors,
CancellationToken cancellationToken)
{
var variableDeclaration = fieldDeclaration.DescendantNodes().OfType <VariableDeclarationSyntax>().FirstOrDefault();
var variableDeclarator = variableDeclaration.DescendantNodes().OfType <VariableDeclaratorSyntax>().FirstOrDefault();
var fieldName = variableDeclarator.Identifier.ValueText;
var model = await document.GetSemanticModelAsync(cancellationToken);
var fieldSymbol = model.GetDeclaredSymbol(variableDeclarator, cancellationToken) as IFieldSymbol;
var trackedRoot = root.TrackNodes(constructors);
foreach (var constructor in constructors)
{
var currentConstructor = trackedRoot.GetCurrentNode(constructor);
var newConstructor = currentConstructor;
string parameterName;
var existingParameter = FindExistingParameter(model, fieldSymbol, constructor, cancellationToken);
if (existingParameter != null)
{
parameterName = existingParameter.Identifier.ValueText;
}
else
{
parameterName = nameGenerator.GetNewParameterName(currentConstructor.ParameterList, fieldName);
newConstructor = currentConstructor.WithParameterList(currentConstructor.ParameterList.AddParameters(
Parameter(Identifier(parameterName))
.WithType(variableDeclaration.Type)));
}
var assignment = newConstructor.ParameterList.Parameters.Any(p => p.Identifier.ValueText == fieldName)
? CreateThisAssignmentStatement(fieldName, parameterName)
: CreateAssignmentStatement(fieldName, parameterName);
newConstructor = newConstructor.WithBody(newConstructor.Body.AddStatements(assignment));
trackedRoot = trackedRoot.ReplaceNode(currentConstructor, newConstructor);
}
return(document.WithSyntaxRoot(trackedRoot));
}
public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
{
VariableDeclaratorSyntax variableDeclaration = node.DescendantNodes().OfType<VariableDeclaratorSyntax>().First();
FieldSymbol field = (FieldSymbol) _semanticModel.GetDeclaredSymbol(variableDeclaration);
if (field != null)
{
var attributes = field.GetAttributes();
foreach (AttributeData attribute in attributes)
{
if (attribute.IsInstanceOfAttributeType<GuardedByAttribute>())
{
GuardedFieldInfo guardedField = new GuardedFieldInfo(node, field, attribute, _semanticModel);
_guardedFields.Add(guardedField);
}
else if (attribute.IsInstanceOfAttributeType<LockAttribute>())
{
LockInfo lockField = new LockInfo(node, field, attribute, _semanticModel);
_locks.Add(lockField);
}
else
{
//do nothing
}
}
}
base.VisitFieldDeclaration(node);
}