private static IEnumerable <ObjectCreationExpressionSyntax> GetObjectCreations(SyntaxNodeAnalysisContext context, ClassDeclarationSyntax classDeclaration, PropertyDeclarationSyntax propertyDeclarationSyntax, IPropertySymbol propertySymbol)
{
var objectCreations = classDeclaration.DescendantNodes()
.OfType <AssignmentExpressionSyntax>()
.Where(a => context.SemanticModel.GetSymbolInfo(a.Left).Symbol.Equals(propertySymbol) && a.Right is ObjectCreationExpressionSyntax)
.Select(a => a.Right as ObjectCreationExpressionSyntax).ToList();
var arrowExpressionClause = propertyDeclarationSyntax.DescendantNodes()
.OfType <ArrowExpressionClauseSyntax>()
.SingleOrDefault(a => a.Expression is ObjectCreationExpressionSyntax)
?.Expression as ObjectCreationExpressionSyntax;
if (arrowExpressionClause != null)
{
objectCreations.Add(arrowExpressionClause);
}
var getAcessorDeclararion = propertyDeclarationSyntax.DescendantNodes()
.OfType <AccessorDeclarationSyntax>()
.SingleOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
if (getAcessorDeclararion != null)
{
objectCreations.AddRange(getAcessorDeclararion.DescendantNodes()
.OfType <ObjectCreationExpressionSyntax>());
}
return(objectCreations);
}
private void AnalyzeMethodInvocationInDacProperty(PropertyDeclarationSyntax property, IEnumerable <INamedTypeSymbol> whiteList,
SyntaxNodeAnalysisContext syntaxContext, PXContext pxContext)
{
foreach (SyntaxNode node in property.DescendantNodes())
{
syntaxContext.CancellationToken.ThrowIfCancellationRequested();
if (node is InvocationExpressionSyntax invocation)
{
ISymbol symbol = syntaxContext.SemanticModel.GetSymbolInfo(invocation, syntaxContext.CancellationToken).Symbol;
if (symbol == null || !(symbol is IMethodSymbol method) || method.IsStatic)
{
continue;
}
bool inWhitelist = whiteList.Any(t => method.ContainingType.Equals(t) ||
method.ContainingType.ConstructedFrom.Equals(t));
if (inWhitelist)
{
continue;
}
syntaxContext.ReportDiagnostic(Diagnostic.Create(Descriptors.PX1032_DacPropertyCannotContainMethodInvocations,
invocation.GetLocation()));
}
else if (node is ObjectCreationExpressionSyntax)
{
syntaxContext.ReportDiagnostic(Diagnostic.Create(Descriptors.PX1032_DacPropertyCannotContainMethodInvocations,
node.GetLocation()));
}
}
}
public static bool HasAttribute(this PropertyDeclarationSyntax prop, string attributeName)
{
return(prop.DescendantNodes()
.OfType <AttributeListSyntax>()
.Any(l => l.Attributes.Any(a =>
a.Name.NormalizeWhitespace().ToFullString()
.Equals(attributeName))));
}
public static AccessorDeclarationSyntax Setter(this PropertyDeclarationSyntax propertyDeclaration)
{
return
(propertyDeclaration
.DescendantNodes()
.OfType <AccessorDeclarationSyntax>()
.FirstOrDefault(d => d.IsKind(SyntaxKind.SetAccessorDeclaration)));
}
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);
}
}
private IEnumerable <string> GetDependsOn(PropertyDeclarationSyntax property, IEnumerable <SimpleProperty> simpleProperties)
{
foreach (var p in property
.DescendantNodes(x => !x.IsKind(SyntaxKind.IdentifierName))
.OfType <IdentifierNameSyntax>())
{
var name = p.Identifier.Text;
var sp = simpleProperties.FirstOrDefault(x => x.Name == name);
if (sp != null)
{
sp.AddDependent(this);
yield return(sp.Name);
}
}
}
private PropertyTransformationResult TransformProperty(PropertyDeclarationSyntax propertyNode, bool canCopy, PropertyTransformationResult result, ITypeTransformationMetadata typeMetadata,
INamespaceTransformationMetadata namespaceMetadata)
{
var analyzeResult = result.AnalyzationResult;
var startRootSpan = analyzeResult.Node.SpanStart;
// Calculate whitespace method trivias
result.EndOfLineTrivia = propertyNode.GetEndOfLine();
result.LeadingWhitespaceTrivia = propertyNode.GetLeadingWhitespace();
result.IndentTrivia = propertyNode.GetIndent(result.LeadingWhitespaceTrivia, typeMetadata.LeadingWhitespaceTrivia);
result.BodyLeadingWhitespaceTrivia = Whitespace(result.LeadingWhitespaceTrivia.ToFullString() + result.IndentTrivia.ToFullString());
if (analyzeResult.Conversion == PropertyConversion.Ignore && analyzeResult.GetAccessors().All(o => o.Conversion == MethodConversion.Ignore))
{
return(result);
}
propertyNode = propertyNode.WithAdditionalAnnotations(new SyntaxAnnotation(result.Annotation));
startRootSpan -= propertyNode.SpanStart;
foreach (var accessorResult in analyzeResult.GetAccessors().Where(o => o.Conversion != MethodConversion.Ignore))
{
var spanStart = accessorResult.Node.SpanStart - startRootSpan;
var spanLength = accessorResult.Node.Span.Length;
var accessorNode = propertyNode.DescendantNodes()
.First(o => o.SpanStart == spanStart && o.Span.Length == spanLength);
var transformedNode = new AccessorTransformationResult(accessorResult);
result.TransformedAccessors.Add(transformedNode);
propertyNode = propertyNode.ReplaceNode(accessorNode, accessorNode.WithAdditionalAnnotations(new SyntaxAnnotation(transformedNode.Annotation)));
}
if (canCopy && result.AnalyzationResult.Conversion == PropertyConversion.Copy)
{
result.Transformed = result.OriginalNode;
}
foreach (var accessorResult in result.TransformedAccessors.OrderByDescending(o => o.OriginalStartSpan))
{
var accessorNode = propertyNode.GetAnnotatedNodes(accessorResult.Annotation)
.First();
TransformPropertyAccessor(accessorNode, result, accessorResult, typeMetadata, namespaceMetadata);
}
return(result);
}
/// <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));
}
public bool IsSuitable(PropertyDeclarationSyntax propertyDeclarationSyntax)
{
return(propertyDeclarationSyntax.DescendantNodes().OfType <LiteralExpressionSyntax>().Any());
}
public static bool HasInitializer(this PropertyDeclarationSyntax propertyDeclaration)
{
Contract.Requires(propertyDeclaration != null);
return(propertyDeclaration.DescendantNodes().Any(n => n is EqualsValueClauseSyntax));
}
