internal static bool TryGetRegisteredName(InvocationExpressionSyntax invocation, SemanticModel semanticModel, CancellationToken cancellationToken, out string registeredName)
{
registeredName = null;
if (invocation == null)
{
return(false);
}
if (TryGetRegisterCall(invocation, semanticModel, cancellationToken, out _) ||
TryGetRegisterReadOnlyCall(invocation, semanticModel, cancellationToken, out _) ||
TryGetRegisterAttachedCall(invocation, semanticModel, cancellationToken, out _) ||
TryGetRegisterAttachedReadOnlyCall(invocation, semanticModel, cancellationToken, out _))
{
return(invocation.TryGetArgumentAtIndex(0, out var nameArg) &&
nameArg.TryGetStringValue(semanticModel, cancellationToken, out registeredName));
}
if (invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
(TryGetAddOwnerCall(invocation, semanticModel, cancellationToken, out _) ||
TryGetOverrideMetadataCall(invocation, semanticModel, cancellationToken, out _)))
{
if (BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(memberAccess.Expression, cancellationToken), out var fieldOrProperty))
{
return(TryGetRegisteredName(fieldOrProperty, semanticModel, cancellationToken, out registeredName));
}
return(false);
}
return(false);
}
internal static bool TryGetDependencyPropertyKeyFieldOrProperty(BackingFieldOrProperty backing, SemanticModel semanticModel, CancellationToken cancellationToken, out BackingFieldOrProperty result)
{
result = default;
if (backing.TryGetAssignedValue(cancellationToken, out var value) &&
semanticModel.TryGetSymbol(value, cancellationToken, out ISymbol symbol))
{
if (symbol is IMethodSymbol method)
{
return(method == KnownSymbols.DependencyProperty.AddOwner &&
value is InvocationExpressionSyntax invocation &&
invocation.Expression is MemberAccessExpressionSyntax member &&
semanticModel.TryGetSymbol(member.Expression, cancellationToken, out ISymbol candidate) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(candidate, out result) &&
TryGetDependencyPropertyKeyFieldOrProperty(result, semanticModel, cancellationToken, out result));
}
else
{
return(symbol is IPropertySymbol property &&
property == KnownSymbols.DependencyPropertyKey.DependencyProperty &&
value is MemberAccessExpressionSyntax memberAccess &&
semanticModel.TryGetSymbol(memberAccess.Expression, cancellationToken, out ISymbol candidate) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(candidate, out result));
}
}
return(false);
}
internal static bool IsAttachedGet(MethodDeclarationSyntax method, SemanticModel semanticModel, CancellationToken cancellationToken, out InvocationExpressionSyntax call, out BackingFieldOrProperty getField)
{
call = null;
getField = default(BackingFieldOrProperty);
if (method == null ||
method.ParameterList.Parameters.Count != 1 ||
method.ReturnType.IsVoid() ||
!method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
return(false);
}
using (var walker = ClrGetterWalker.Borrow(semanticModel, cancellationToken, method))
{
call = walker.GetValue;
var memberAccess = walker.GetValue?.Expression as MemberAccessExpressionSyntax;
var member = memberAccess?.Expression as IdentifierNameSyntax;
if (memberAccess == null ||
member == null ||
!memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
return(false);
}
if (method.ParameterList.Parameters[0].Identifier.ValueText != member.Identifier.ValueText)
{
return(false);
}
return(BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(walker.Property.Expression, cancellationToken), out getField));
}
}
/// <inheritdoc/>
protected override async Task RegisterCodeFixesAsync(DocumentEditorCodeFixContext context)
{
var document = context.Document;
var syntaxRoot = await document.GetSyntaxRootAsync(context.CancellationToken)
.ConfigureAwait(false);
var semanticModel = await document.GetSemanticModelAsync(context.CancellationToken)
.ConfigureAwait(false);
foreach (var diagnostic in context.Diagnostics)
{
var token = syntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start);
if (string.IsNullOrEmpty(token.ValueText))
{
continue;
}
if (syntaxRoot.TryFindNodeOrAncestor(diagnostic, out MemberDeclarationSyntax member) &&
semanticModel.TryGetSymbol(member, context.CancellationToken, out ISymbol symbol) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(symbol, out var fieldOrProperty) &&
DependencyProperty.TryGetRegisteredName(fieldOrProperty, semanticModel, context.CancellationToken, out var name))
{
context.RegisterCodeFix(
"Add standard documentation.",
(editor, _) => editor.ReplaceNode(member, x => x.WithDocumentationText($"/// <summary>Identifies the <see cref=\"{name}\"/> dependency property.</summary>")),
this.GetType(),
diagnostic);
}
}
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (context.IsExcludedFromAnalysis())
{
return;
}
if (context.Node is InvocationExpressionSyntax invocation &&
context.ContainingSymbol.IsStatic)
{
if (invocation.TryGetArgumentAtIndex(2, out var argument) &&
(DependencyProperty.TryGetRegisterCall(invocation, context.SemanticModel, context.CancellationToken, out _) ||
DependencyProperty.TryGetRegisterReadOnlyCall(invocation, context.SemanticModel, context.CancellationToken, out _) ||
DependencyProperty.TryGetRegisterAttachedCall(invocation, context.SemanticModel, context.CancellationToken, out _) ||
DependencyProperty.TryGetRegisterAttachedReadOnlyCall(invocation, context.SemanticModel, context.CancellationToken, out _)))
{
HandleArgument(context, argument);
}
else if (invocation.TryGetArgumentAtIndex(0, out argument))
{
if (DependencyProperty.TryGetAddOwnerCall(invocation, context.SemanticModel, context.CancellationToken, out _))
{
HandleArgument(context, argument);
}
else if (DependencyProperty.TryGetOverrideMetadataCall(invocation, context.SemanticModel, context.CancellationToken, out _) &&
invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
BackingFieldOrProperty.TryCreateForDependencyProperty(context.SemanticModel.GetSymbolSafe(memberAccess.Expression, context.CancellationToken), out var fieldOrProperty) &&
context.ContainingSymbol.ContainingType.IsAssignableTo(fieldOrProperty.ContainingType, context.Compilation))
{
HandleArgument(context, argument);
}
}
}
}
/// <summary>
/// Get the backing fields for the <paramref name="propertyDeclaration"/> these are different for readonly dependency properties where the setter returns the DependencyPropertyKey field.
/// </summary>
internal static bool TryGetBackingFields(PropertyDeclarationSyntax propertyDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken, out BackingFieldOrProperty getField, out BackingFieldOrProperty setField)
{
getField = default;
setField = default;
if (propertyDeclaration.TryGetGetter(out var getAccessor) &&
propertyDeclaration.TryGetSetter(out var setAccessor))
{
using (var getterWalker = ClrGetterWalker.Borrow(semanticModel, cancellationToken, getAccessor))
{
using (var setterWalker = ClrSetterWalker.Borrow(semanticModel, cancellationToken, setAccessor))
{
if (getterWalker.HasError ||
setterWalker.HasError)
{
return(false);
}
if (getterWalker.IsSuccess &&
BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(getterWalker.Property.Expression, cancellationToken), out getField) &&
setterWalker.IsSuccess &&
BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(setterWalker.Property.Expression, cancellationToken), out setField))
{
return(true);
}
var property = semanticModel.GetSymbolSafe(propertyDeclaration, cancellationToken) as IPropertySymbol;
return(TryGetBackingFieldsByName(property, semanticModel.Compilation, out getField, out setField));
}
}
}
return(false);
}
internal static bool TryGetRegisteredName(InvocationExpressionSyntax invocation, SemanticModel semanticModel, CancellationToken cancellationToken, out ArgumentSyntax nameArg, out string registeredName)
{
nameArg = null;
registeredName = null;
if (invocation == null)
{
return(false);
}
if (TryGetRegisterCall(invocation, semanticModel, cancellationToken, out var method) ||
TryGetRegisterReadOnlyCall(invocation, semanticModel, cancellationToken, out method) ||
TryGetRegisterAttachedCall(invocation, semanticModel, cancellationToken, out method) ||
TryGetRegisterAttachedReadOnlyCall(invocation, semanticModel, cancellationToken, out method))
{
return(method.TryFindParameter("name", out var parameter) &&
invocation.TryFindArgument(parameter, out nameArg) &&
nameArg.TryGetStringValue(semanticModel, cancellationToken, out registeredName));
}
if (invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
(TryGetAddOwnerCall(invocation, semanticModel, cancellationToken, out _) ||
TryGetOverrideMetadataCall(invocation, semanticModel, cancellationToken, out _)))
{
if (semanticModel.TryGetSymbol(memberAccess.Expression, cancellationToken, out var symbol) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(symbol, out var fieldOrProperty))
{
return(TryGetRegisteredName(fieldOrProperty, semanticModel, cancellationToken, out nameArg, out registeredName));
}
return(false);
}
return(false);
}
internal static bool IsAttachedSet(MethodDeclarationSyntax method, SemanticModel semanticModel, CancellationToken cancellationToken, out InvocationExpressionSyntax setValueCall, out BackingFieldOrProperty setField)
{
setValueCall = null;
setField = default(BackingFieldOrProperty);
if (method == null ||
method.ParameterList.Parameters.Count != 2 ||
!method.ReturnType.IsVoid() ||
!method.Modifiers.Any(SyntaxKind.StaticKeyword))
{
return(false);
}
using (var walker = ClrSetterWalker.Borrow(semanticModel, cancellationToken, method))
{
if (!walker.IsSuccess)
{
return(false);
}
setValueCall = walker.SetValue ?? walker.SetCurrentValue;
if (setValueCall.Expression is MemberAccessExpressionSyntax memberAccess &&
memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
memberAccess.Expression is IdentifierNameSyntax member)
{
if (method.ParameterList.Parameters[0].Identifier.ValueText != member.Identifier.ValueText)
{
return(false);
}
if (setValueCall.TryGetArgumentAtIndex(1, out var arg) &&
method.ParameterList.Parameters.TryElementAt(1, out var parameter))
{
if (arg.Expression is IdentifierNameSyntax argIdentifier &&
argIdentifier.Identifier.ValueText == parameter.Identifier.ValueText)
{
return(BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(walker.Property.Expression, cancellationToken), out setField));
}
if (arg.Expression is InvocationExpressionSyntax invocation &&
invocation.TrySingleArgument(out var nestedArg) &&
nestedArg.Expression is IdentifierNameSyntax nestedArgId &&
nestedArgId.Identifier.ValueText == parameter.Identifier.ValueText)
{
return(BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(walker.Property.Expression, cancellationToken), out setField));
}
if (arg.Expression is ConditionalExpressionSyntax ternary &&
ternary.Condition is IdentifierNameSyntax conditionIdentifier &&
conditionIdentifier.Identifier.ValueText == parameter.Identifier.ValueText)
{
return(BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(walker.Property.Expression, cancellationToken), out setField));
}
}
}
return(false);
}
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is MemberDeclarationSyntax memberDeclaration)
{
if (BackingFieldOrProperty.TryCreateForDependencyProperty(context.ContainingSymbol, out var backingMember))
{
if (DependencyProperty.TryGetRegisteredName(backingMember, context.SemanticModel, context.CancellationToken, out _, out var registeredName))
{
if (backingMember.Type == KnownSymbols.DependencyProperty &&
!backingMember.Name.IsParts(registeredName, "Property"))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0001BackingFieldShouldMatchRegisteredName,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add("ExpectedName", registeredName + "Property"),
backingMember.Name,
registeredName));
}
if (backingMember.Type == KnownSymbols.DependencyPropertyKey &&
!backingMember.Name.IsParts(registeredName, "PropertyKey"))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0002BackingFieldShouldMatchRegisteredName,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add("ExpectedName", registeredName + "PropertyKey"),
backingMember.Name,
registeredName));
}
if (context.ContainingSymbol.ContainingType.TryFindProperty(registeredName, out _) &&
context.ContainingSymbol.DeclaredAccessibility.IsEither(Accessibility.Protected, Accessibility.Internal, Accessibility.Public) &&
!HasStandardText(memberDeclaration, registeredName, out var comment))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0060DocumentDependencyPropertyBackingMember,
comment == null
? BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation()
: comment.GetLocation(),
properties: ImmutableDictionary <string, string> .Empty.Add(nameof(CrefParameterSyntax), registeredName)));
}
if (DependencyProperty.TryGetRegisteredType(backingMember, context.SemanticModel, context.CancellationToken, out var type) &&
type.Is(KnownSymbols.Style) &&
!TryFindStyleTypedPropertyAttribute(memberDeclaration, registeredName, context.SemanticModel, context.CancellationToken) &&
backingMember.FieldOrProperty.Symbol.DeclaredAccessibility.IsEither(Accessibility.Public, Accessibility.Internal))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0176StyleTypedPropertyMissing,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add(
nameof(AttributeListSyntax),
$"[StyleTypedProperty(Property = {(context.ContainingSymbol.ContainingType.TryFindProperty(registeredName, out _) ? $"nameof({registeredName})" : $"\"{registeredName}\"")}, StyleTargetType = typeof(TYPE))]"),
internal static bool TryGetDependencyAddOwnerSourceField(BackingFieldOrProperty fieldOrProperty, SemanticModel semanticModel, CancellationToken cancellationToken, out BackingFieldOrProperty result)
{
result = default;
if (fieldOrProperty.TryGetAssignedValue(cancellationToken, out var value) &&
value is InvocationExpressionSyntax invocation &&
semanticModel.TryGetSymbol(invocation, KnownSymbols.DependencyProperty.AddOwner, cancellationToken, out _))
{
var addOwner = (MemberAccessExpressionSyntax)invocation.Expression;
return(BackingFieldOrProperty.TryCreateForDependencyProperty(
semanticModel.GetSymbolSafe(addOwner.Expression, cancellationToken),
out result));
}
return(false);
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is InvocationExpressionSyntax invocation &&
DependencyProperty.TryGetOverrideMetadataCall(invocation, context.SemanticModel, context.CancellationToken, out var method) &&
invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
context.SemanticModel.TryGetSymbol(memberAccess.Expression, context.CancellationToken, out ISymbol candidate) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(candidate, out var fieldOrProperty) &&
method.TryFindParameter(KnownSymbols.PropertyMetadata, out var parameter) &&
invocation.TryFindArgument(parameter, out var metadataArg))
{
if (fieldOrProperty.TryGetAssignedValue(context.CancellationToken, out var value) &&
value is InvocationExpressionSyntax registerInvocation)
{
if (DependencyProperty.TryGetRegisterCall(registerInvocation, context.SemanticModel, context.CancellationToken, out var registerMethod) ||
DependencyProperty.TryGetRegisterReadOnlyCall(registerInvocation, context.SemanticModel, context.CancellationToken, out registerMethod) ||
DependencyProperty.TryGetRegisterAttachedCall(registerInvocation, context.SemanticModel, context.CancellationToken, out registerMethod) ||
DependencyProperty.TryGetRegisterAttachedReadOnlyCall(registerInvocation, context.SemanticModel, context.CancellationToken, out registerMethod))
{
if (registerMethod.TryFindParameter(KnownSymbols.PropertyMetadata, out var registerParameter) &&
registerInvocation.TryFindArgument(registerParameter, out var registeredMetadataArg) &&
context.SemanticModel.TryGetType(metadataArg.Expression, context.CancellationToken, out var type) &&
context.SemanticModel.TryGetType(registeredMetadataArg.Expression, context.CancellationToken, out var registeredType) &&
!type.IsAssignableTo(registeredType, context.Compilation))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptors.WPF0017MetadataMustBeAssignable, metadataArg.GetLocation()));
}
}
}
else if (fieldOrProperty.Symbol == KnownSymbols.FrameworkElement.DefaultStyleKeyProperty &&
metadataArg.Expression is ObjectCreationExpressionSyntax metadataCreation)
{
if (!context.SemanticModel.TryGetSymbol(metadataCreation, KnownSymbols.FrameworkPropertyMetadata, context.CancellationToken, out _))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptors.WPF0017MetadataMustBeAssignable, metadataArg.GetLocation()));
}
else if (metadataCreation.TrySingleArgument(out var typeArg) &&
typeArg.Expression is TypeOfExpressionSyntax typeOf &&
typeOf.Type is IdentifierNameSyntax typeName &&
typeName.Identifier.ValueText != context.ContainingSymbol.ContainingType.MetadataName)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptors.WPF0018DefaultStyleKeyPropertyOverrideMetadataArgument, typeArg.GetLocation()));
}
}
}
}
private static void HandleInvocation(SyntaxNodeAnalysisContext context)
{
if (context.IsExcludedFromAnalysis())
{
return;
}
if (context.Node is InvocationExpressionSyntax invocation &&
!IsInObjectInitializer(invocation) &&
!IsInConstructor(invocation) &&
DependencyObject.TryGetSetValueCall(invocation, context.SemanticModel, context.CancellationToken, out _))
{
var propertyArg = invocation.ArgumentList.Arguments[0];
if (!BackingFieldOrProperty.TryCreateForDependencyProperty(context.SemanticModel.GetSymbolSafe(propertyArg.Expression, context.CancellationToken), out var propertyMember) ||
propertyMember.Type == KnownSymbol.DependencyPropertyKey)
{
return;
}
if (propertyMember.Symbol is IFieldSymbol field &&
field == KnownSymbol.FrameworkElement.DataContextProperty)
{
return;
}
var clrProperty = context.ContainingProperty();
if (clrProperty.IsDependencyPropertyAccessor(context.SemanticModel, context.CancellationToken))
{
return;
}
var clrMethod = context.ContainingSymbol as IMethodSymbol;
if (ClrMethod.IsAttachedSet(clrMethod, context.SemanticModel, context.CancellationToken, out propertyMember))
{
return;
}
if (IsCalleePotentiallyCreatedInScope(invocation.Expression as MemberAccessExpressionSyntax, context.SemanticModel, context.CancellationToken))
{
return;
}
context.ReportDiagnostic(Diagnostic.Create(Descriptor, invocation.GetLocation(), propertyMember, invocation.ArgumentList.Arguments[1]));
}
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is InvocationExpressionSyntax invocation &&
TryGetArgs(context, out var target, out var propertyArg, out var valueArg) &&
context.SemanticModel.TryGetSymbol(propertyArg.Expression, context.CancellationToken, out var symbol) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(symbol, out var fieldOrProperty))
{
if (IsWrongType(fieldOrProperty, valueArg, context, out var registeredType))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0014SetValueMustUseRegisteredType,
valueArg.GetLocation(),
target.Name,
registeredType));
}
if (fieldOrProperty.Type == KnownSymbols.DependencyProperty &&
DependencyProperty.TryGetDependencyPropertyKeyFieldOrProperty(fieldOrProperty, context.SemanticModel, context.CancellationToken, out var keyField))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0040SetUsingDependencyPropertyKey,
propertyArg.GetLocation(),
properties: ImmutableDictionary <string, string> .Empty.Add(nameof(DependencyPropertyKeyType), keyField.Name),
propertyArg,
keyField.CreateArgument(context.SemanticModel, propertyArg.SpanStart)));
}
if (target == KnownSymbols.DependencyObject.SetCurrentValue &&
fieldOrProperty.Symbol is IFieldSymbol setField &&
setField == KnownSymbols.FrameworkElement.DataContextProperty)
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0043DoNotUseSetCurrentValueForDataContext,
invocation.GetLocation(),
setField.Name,
invocation.ArgumentList.Arguments[1]));
}
}
}
private static void HandleInvocation(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is InvocationExpressionSyntax invocation &&
!IsInConstructor(invocation) &&
invocation.ArgumentList is ArgumentListSyntax argumentList &&
argumentList.Arguments.Count == 2 &&
argumentList.Arguments.TryElementAt(0, out var propertyArg) &&
DependencyObject.TryGetSetValueCall(invocation, context.SemanticModel, context.CancellationToken, out _) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(context.SemanticModel.GetSymbolSafe(propertyArg.Expression, context.CancellationToken), out var backingFieldOrProperty) &&
!IsCalleePotentiallyCreatedInScope(invocation.Expression as MemberAccessExpressionSyntax, context.SemanticModel, context.CancellationToken))
{
if (backingFieldOrProperty.Type == KnownSymbols.DependencyPropertyKey)
{
return;
}
if (backingFieldOrProperty.Symbol is IFieldSymbol field &&
field == KnownSymbols.FrameworkElement.DataContextProperty)
{
return;
}
var clrProperty = context.ContainingProperty();
if (clrProperty.IsDependencyPropertyAccessor(context.SemanticModel, context.CancellationToken))
{
return;
}
var clrMethod = context.ContainingSymbol as IMethodSymbol;
if (ClrMethod.IsAttachedSet(clrMethod, context.SemanticModel, context.CancellationToken, out backingFieldOrProperty))
{
return;
}
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0041SetMutableUsingSetCurrentValue,
invocation.GetLocation(),
backingFieldOrProperty,
invocation.ArgumentList.Arguments[1]));
}
}
/// <summary>
/// Get the backing fields for the <paramref name="property"/> these are different for readonly dependency properties where the setter returns the DependencyPropertyKey field.
/// This method looks for fields that matches the name NameProperty and NamePropertyKey.
/// </summary>
private static bool TryGetBackingFieldsByName(IPropertySymbol property, Compilation compilation, out BackingFieldOrProperty getter, out BackingFieldOrProperty setter)
{
getter = default;
setter = default;
if (property == null ||
!property.ContainingType.IsAssignableTo(KnownSymbols.DependencyObject, compilation))
{
return(false);
}
foreach (var member in property.ContainingType.GetMembers())
{
if (BackingFieldOrProperty.TryCreateForDependencyProperty(member, out var candidate))
{
if (candidate.Name.IsParts(property.Name, "Property"))
{
if (!DependencyProperty.IsPotentialDependencyPropertyBackingField(candidate))
{
return(false);
}
getter = candidate;
}
if (candidate.Name.IsParts(property.Name, "PropertyKey"))
{
if (!DependencyProperty.IsPotentialDependencyPropertyKeyBackingField(candidate))
{
return(false);
}
setter = candidate;
}
}
}
if (setter.Symbol == null)
{
setter = getter;
}
return(setter.Symbol != null);
}
internal static bool TryGetDependencyProperty(ObjectCreationExpressionSyntax objectCreation, SemanticModel semanticModel, CancellationToken cancellationToken, out BackingFieldOrProperty fieldOrProperty)
{
fieldOrProperty = default;
var invocation = objectCreation.FirstAncestorOrSelf <InvocationExpressionSyntax>();
if (invocation == null)
{
return(false);
}
if (DependencyProperty.TryGetRegisterCall(invocation, semanticModel, cancellationToken, out _) ||
DependencyProperty.TryGetRegisterReadOnlyCall(invocation, semanticModel, cancellationToken, out _) ||
DependencyProperty.TryGetRegisterAttachedCall(invocation, semanticModel, cancellationToken, out _) ||
DependencyProperty.TryGetRegisterAttachedReadOnlyCall(invocation, semanticModel, cancellationToken, out _))
{
if (objectCreation.TryFirstAncestor <FieldDeclarationSyntax>(out var fieldDeclaration) &&
semanticModel.TryGetSymbol(fieldDeclaration, cancellationToken, out var field))
{
return(BackingFieldOrProperty.TryCreateForDependencyProperty(field, out fieldOrProperty));
}
if (objectCreation.TryFirstAncestor <PropertyDeclarationSyntax>(out var propertyDeclaration) &&
semanticModel.TryGetSymbol(propertyDeclaration, cancellationToken, out var property))
{
return(BackingFieldOrProperty.TryCreateForDependencyProperty(property, out fieldOrProperty));
}
return(false);
}
if (invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
(DependencyProperty.TryGetAddOwnerCall(invocation, semanticModel, cancellationToken, out _) ||
DependencyProperty.TryGetOverrideMetadataCall(invocation, semanticModel, cancellationToken, out _)) &&
semanticModel.TryGetSymbol(memberAccess.Expression, cancellationToken, out ISymbol? candidate))
{
return(BackingFieldOrProperty.TryCreateForDependencyProperty(candidate, out fieldOrProperty));
}
return(false);
}
/// <summary>
/// Get the backing fields for the <paramref name="property"/> these are different for readonly dependency properties where the setter returns the DependencyPropertyKey field.
/// </summary>
private static bool TryGetBackingFields(IPropertySymbol property, SemanticModel semanticModel, CancellationToken cancellationToken, out BackingFieldOrProperty getField, out BackingFieldOrProperty setField)
{
getField = default;
setField = default;
if (property.IsPotentialClrProperty(semanticModel.Compilation) &&
property.TrySingleDeclaration(cancellationToken, out PropertyDeclarationSyntax propertyDeclaration) &&
TryGetBackingFields(propertyDeclaration, semanticModel, cancellationToken, out getField, out setField))
{
if (getField.ContainingType.IsGenericType)
{
return(property.ContainingType.TryFindFirstMember(getField.Name, out var getMember) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(getMember, out getField) &&
property.ContainingType.TryFindFirstMember(setField.Name, out var setMember) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(setMember, out setField));
}
return(true);
}
return(false);
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is MemberDeclarationSyntax memberDeclaration)
{
if (BackingFieldOrProperty.TryCreateForDependencyProperty(context.ContainingSymbol, out var backing))
{
if (DependencyProperty.TryGetRegisteredName(backing, context.SemanticModel, context.CancellationToken, out _, out var registeredName))
{
if (backing.Type == KnownSymbols.DependencyProperty &&
!backing.Name.IsParts(registeredName, "Property"))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0001BackingFieldShouldMatchRegisteredName,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add("ExpectedName", registeredName + "Property"),
backing.Name,
registeredName));
}
if (backing.Type == KnownSymbols.DependencyPropertyKey &&
!backing.Name.IsParts(registeredName, "PropertyKey"))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0002BackingFieldShouldMatchRegisteredName,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add("ExpectedName", registeredName + "PropertyKey"),
backing.Name,
registeredName));
}
if (context.ContainingSymbol.ContainingType.TryFindProperty(registeredName, out _) &&
context.ContainingSymbol.DeclaredAccessibility.IsEither(Accessibility.Protected, Accessibility.Internal, Accessibility.Public))
{
var summaryFormat = "<summary>Identifies the <see cref=\"{backing}\"/> dependency property.</summary>";
if (memberDeclaration.TryGetDocumentationComment(out var comment))
{
if (comment.VerifySummary(summaryFormat, registeredName) is { } summaryError)
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0060DocumentDependencyPropertyBackingMember,
summaryError.Location,
ImmutableDictionary <string, string> .Empty.Add(nameof(DocComment), summaryError.Text)));
}
}
else
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0060DocumentDependencyPropertyBackingMember,
backing.Symbol.Locations[0],
ImmutableDictionary <string, string> .Empty.Add(
nameof(DocComment),
$"/// {DocComment.Format(summaryFormat, registeredName)}")));
}
}
if (DependencyProperty.TryGetRegisteredType(backing, context.SemanticModel, context.CancellationToken, out var type) &&
type.Is(KnownSymbols.Style) &&
!TryFindStyleTypedPropertyAttribute(memberDeclaration, registeredName, context.SemanticModel, context.CancellationToken) &&
backing.FieldOrProperty.Symbol.DeclaredAccessibility.IsEither(Accessibility.Public, Accessibility.Internal))
{
context.ReportDiagnostic(
Diagnostic.Create(
Descriptors.WPF0176StyleTypedPropertyMissing,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add(
nameof(AttributeListSyntax),
$"[StyleTypedProperty(Property = {(context.ContainingSymbol.ContainingType.TryFindProperty(registeredName, out _) ? $"nameof({registeredName})" : $"\"{registeredName}\"")}, StyleTargetType = typeof(TYPE))]"),
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var syntaxRoot = await document.GetSyntaxRootAsync(context.CancellationToken)
.ConfigureAwait(false);
var semanticModel = await document.GetSemanticModelAsync(context.CancellationToken)
.ConfigureAwait(false);
foreach (var diagnostic in context.Diagnostics)
{
var token = syntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start);
if (string.IsNullOrEmpty(token.ValueText))
{
continue;
}
var invocation = syntaxRoot.FindNode(diagnostic.Location.SourceSpan)
.FirstAncestorOrSelf <InvocationExpressionSyntax>();
if (invocation == null || invocation.IsMissing)
{
continue;
}
if (DependencyObject.TryGetSetValueCall(invocation, semanticModel, context.CancellationToken, out _) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(invocation.ArgumentList.Arguments[0].Expression, context.CancellationToken), out var fieldOrProperty))
{
if (DependencyProperty.TryGetDependencyPropertyKeyField(
fieldOrProperty,
semanticModel,
context.CancellationToken,
out var keyField))
{
context.RegisterCodeFix(
CodeAction.Create(
invocation.ToString(),
cancellationToken => ApplyFixAsync(
context.Document,
invocation,
null,
keyField.CreateArgument(semanticModel, token.SpanStart),
cancellationToken),
this.GetType().FullName),
diagnostic);
}
continue;
}
if (DependencyObject.TryGetSetCurrentValueCall(invocation, semanticModel, context.CancellationToken, out _) &&
BackingFieldOrProperty.TryCreateForDependencyProperty(semanticModel.GetSymbolSafe(invocation.ArgumentList.Arguments[0].Expression, context.CancellationToken), out fieldOrProperty))
{
if (DependencyProperty.TryGetDependencyPropertyKeyField(
fieldOrProperty,
semanticModel,
context.CancellationToken,
out var keyField))
{
context.RegisterCodeFix(
CodeAction.Create(
invocation.ToString(),
cancellationToken => ApplyFixAsync(
context.Document,
invocation,
SetValueExpression(invocation.Expression),
keyField.CreateArgument(semanticModel, token.SpanStart),
cancellationToken),
this.GetType().FullName),
diagnostic);
}
}
}
}
private static void Handle(SyntaxNodeAnalysisContext context)
{
if (!context.IsExcludedFromAnalysis() &&
context.Node is MemberDeclarationSyntax memberDeclaration)
{
if (BackingFieldOrProperty.TryCreateForDependencyProperty(context.ContainingSymbol, out var backingMember))
{
if (DependencyProperty.TryGetRegisteredName(backingMember, context.SemanticModel, context.CancellationToken, out var registeredName))
{
if (backingMember.Type == KnownSymbol.DependencyProperty &&
!backingMember.Name.IsParts(registeredName, "Property"))
{
context.ReportDiagnostic(
Diagnostic.Create(
WPF0001BackingFieldShouldMatchRegisteredName.Descriptor,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add("ExpectedName", registeredName + "Property"),
backingMember.Name,
registeredName));
}
if (backingMember.Type == KnownSymbol.DependencyPropertyKey &&
!backingMember.Name.IsParts(registeredName, "PropertyKey"))
{
context.ReportDiagnostic(
Diagnostic.Create(
WPF0002BackingFieldShouldMatchRegisteredName.Descriptor,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
ImmutableDictionary <string, string> .Empty.Add("ExpectedName", registeredName + "PropertyKey"),
backingMember.Name,
registeredName));
}
if (context.ContainingSymbol.DeclaredAccessibility.IsEither(
Accessibility.Protected, Accessibility.Internal, Accessibility.Public) &&
context.ContainingSymbol.ContainingType.TryFindProperty(registeredName, out _) &&
!HasStandardText(memberDeclaration, registeredName, out var comment))
{
context.ReportDiagnostic(
Diagnostic.Create(
WPF0060DocumentDependencyPropertyBackingMember.Descriptor,
comment == null
? BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation()
: comment.GetLocation()));
}
}
if (context.Node is FieldDeclarationSyntax fieldDeclaration &&
DependencyProperty.TryGetDependencyPropertyKeyField(
backingMember, context.SemanticModel, context.CancellationToken, out var keyField) &&
Equals(backingMember.ContainingType, keyField.ContainingType) &&
keyField.TryGetSyntaxReference(out var reference))
{
var keyNode = reference.GetSyntax(context.CancellationToken);
if (ReferenceEquals(fieldDeclaration.SyntaxTree, keyNode.SyntaxTree) &&
fieldDeclaration.SpanStart < keyNode.SpanStart)
{
context.ReportDiagnostic(
Diagnostic.Create(
WPF0031FieldOrder.Descriptor,
fieldDeclaration.GetLocation(),
keyField.Name,
backingMember.Name));
}
}
}
if (BackingFieldOrProperty.TryCreateCandidate(context.ContainingSymbol, out var candidate) &&
DependencyProperty.TryGetRegisterInvocationRecursive(candidate, context.SemanticModel, context.CancellationToken, out _, out _) &&
!candidate.FieldOrProperty.IsStaticReadOnly())
{
context.ReportDiagnostic(
Diagnostic.Create(
WPF0030BackingFieldShouldBeStaticReadonly.Descriptor,
BackingFieldOrProperty.FindIdentifier(memberDeclaration).GetLocation(),
candidate.Name,
candidate.Type.Name));
}
}
}