Tom Edwards
3 years ago
9 changed files with 850 additions and 6 deletions
@ -0,0 +1,17 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
|
|||
<PropertyGroup> |
|||
<TargetFramework>netstandard2.0</TargetFramework> |
|||
<Nullable>enable</Nullable> |
|||
<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules> |
|||
</PropertyGroup> |
|||
|
|||
<ItemGroup> |
|||
<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4"> |
|||
<PrivateAssets>all</PrivateAssets> |
|||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> |
|||
</PackageReference> |
|||
<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" /> |
|||
</ItemGroup> |
|||
|
|||
</Project> |
|||
@ -0,0 +1,555 @@ |
|||
using System; |
|||
using System.Collections.Concurrent; |
|||
using System.Collections.Generic; |
|||
using System.Collections.Immutable; |
|||
using System.Linq; |
|||
using System.Text.RegularExpressions; |
|||
using System.Threading; |
|||
using System.Threading.Tasks; |
|||
using Microsoft.CodeAnalysis; |
|||
using Microsoft.CodeAnalysis.CSharp; |
|||
using Microsoft.CodeAnalysis.Diagnostics; |
|||
using Microsoft.CodeAnalysis.Operations; |
|||
|
|||
namespace Avalonia.Analyzers; |
|||
|
|||
public partial class AvaloniaPropertyAnalyzer |
|||
{ |
|||
public class CompileAnalyzer |
|||
{ |
|||
/// <summary>
|
|||
/// A dictionary that maps field/property symbols to the AvaloniaProperty objects assigned to them.
|
|||
/// </summary>
|
|||
private readonly ConcurrentDictionary<ISymbol, AvaloniaPropertyDescription> _avaloniaProperyDescriptions = new(SymbolEqualityComparer.Default); |
|||
|
|||
private readonly ConcurrentDictionary<IPropertySymbol, ImmutableArray<AvaloniaPropertyDescription>> _clrPropertyToAvaloniaProperties = new(SymbolEqualityComparer.Default); |
|||
|
|||
private readonly INamedTypeSymbol _avaloniaObjectType; |
|||
private readonly ImmutableHashSet<IMethodSymbol> _getValueMethods; |
|||
private readonly ImmutableHashSet<IMethodSymbol> _setValueMethods; |
|||
private readonly INamedTypeSymbol _avaloniaPropertyType; |
|||
private readonly INamedTypeSymbol _styledPropertyType; |
|||
private readonly INamedTypeSymbol _attachedPropertyType; |
|||
private readonly INamedTypeSymbol _directPropertyType; |
|||
private readonly ImmutableHashSet<IMethodSymbol> _avaloniaPropertyRegisterMethods; |
|||
private readonly ImmutableHashSet<IMethodSymbol> _avaloniaPropertyAddOwnerMethods; |
|||
|
|||
public CompileAnalyzer(CompilationStartAnalysisContext context) |
|||
{ |
|||
_avaloniaObjectType = GetTypeOrThrow("Avalonia.AvaloniaObject"); |
|||
_getValueMethods = _avaloniaObjectType.GetMembers("GetValue").OfType<IMethodSymbol>().ToImmutableHashSet<IMethodSymbol>(SymbolEqualityComparer.Default); |
|||
_setValueMethods = _avaloniaObjectType.GetMembers("SetValue").OfType<IMethodSymbol>().ToImmutableHashSet<IMethodSymbol>(SymbolEqualityComparer.Default); |
|||
|
|||
_avaloniaPropertyType = GetTypeOrThrow("Avalonia.AvaloniaProperty"); |
|||
_styledPropertyType = GetTypeOrThrow("Avalonia.StyledProperty`1"); |
|||
_attachedPropertyType = GetTypeOrThrow("Avalonia.AttachedProperty`1"); |
|||
_directPropertyType = GetTypeOrThrow("Avalonia.DirectProperty`2"); |
|||
|
|||
_avaloniaPropertyRegisterMethods = _avaloniaPropertyType.GetMembers() |
|||
.OfType<IMethodSymbol>().Where(m => m.Name.StartsWith("Register")).ToImmutableHashSet<IMethodSymbol>(SymbolEqualityComparer.Default); |
|||
|
|||
_avaloniaPropertyAddOwnerMethods = new[] { _styledPropertyType, _attachedPropertyType, _directPropertyType } |
|||
.SelectMany(t => t.GetMembers("AddOwner").OfType<IMethodSymbol>()).ToImmutableHashSet<IMethodSymbol>(SymbolEqualityComparer.Default); |
|||
|
|||
FindAvaloniaPropertySymbols(context.Compilation, context.CancellationToken); |
|||
|
|||
context.RegisterOperationAction(AnalyzeFieldInitializer, OperationKind.FieldInitializer); |
|||
context.RegisterOperationAction(AnalyzePropertyInitializer, OperationKind.PropertyInitializer); |
|||
|
|||
context.RegisterSymbolStartAction(StartPropertySymbolAnalysis, SymbolKind.Property); |
|||
|
|||
if (context.Compilation.Language == LanguageNames.CSharp) |
|||
{ |
|||
context.RegisterCodeBlockAction(AnalyzePropertyMethods); |
|||
} |
|||
|
|||
INamedTypeSymbol GetTypeOrThrow(string name) => context.Compilation.GetTypeByMetadataName(name) ?? throw new KeyNotFoundException($"Could not locate {name} in the compilation context."); |
|||
} |
|||
|
|||
private void FindAvaloniaPropertySymbols(Compilation compilation, CancellationToken cancellationToken) |
|||
{ |
|||
var namespaceStack = new Stack<INamespaceSymbol>(); |
|||
namespaceStack.Push(compilation.GlobalNamespace); |
|||
|
|||
var types = new List<INamedTypeSymbol>(); |
|||
|
|||
while (namespaceStack.Count > 0) |
|||
{ |
|||
var current = namespaceStack.Pop(); |
|||
|
|||
foreach (var type in current.GetTypeMembers()) |
|||
{ |
|||
if (DerivesFrom(type, _avaloniaObjectType)) |
|||
{ |
|||
types.Add(type); |
|||
} |
|||
} |
|||
|
|||
foreach (var child in current.GetNamespaceMembers()) |
|||
{ |
|||
namespaceStack.Push(child); |
|||
} |
|||
} |
|||
|
|||
var references = new ConcurrentBag<(ISymbol symbol, Func<ISymbolInitializerOperation, IEnumerable<ISymbol>> getInits)>(); |
|||
|
|||
var parallelOptions = new ParallelOptions() { CancellationToken = cancellationToken }; |
|||
|
|||
Parallel.ForEach(types, parallelOptions, type => |
|||
{ |
|||
foreach (var member in type.GetMembers()) |
|||
{ |
|||
switch (member) |
|||
{ |
|||
case IFieldSymbol fieldSymbol when IsValidAvaloniaPropertyStorage(fieldSymbol): |
|||
references.Add((fieldSymbol, so => ((IFieldInitializerOperation)so).InitializedFields)); |
|||
break; |
|||
case IPropertySymbol propertySymbol when IsValidAvaloniaPropertyStorage(propertySymbol): |
|||
references.Add((propertySymbol, so => ((IPropertyInitializerOperation)so).InitializedProperties)); |
|||
break; |
|||
} |
|||
} |
|||
}); |
|||
|
|||
// key initializes value
|
|||
var fieldInitializations = new ConcurrentDictionary<ISymbol, ISymbol>(SymbolEqualityComparer.Default); |
|||
|
|||
Parallel.ForEach(references, parallelOptions, tuple => |
|||
{ |
|||
foreach (var syntaxRef in tuple.symbol.DeclaringSyntaxReferences) |
|||
{ |
|||
var node = syntaxRef.GetSyntax(cancellationToken); |
|||
if (!compilation.ContainsSyntaxTree(node.SyntaxTree)) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
var model = compilation.GetSemanticModel(node.SyntaxTree); |
|||
var operation = node.ChildNodes().Select(n => model.GetOperation(n, cancellationToken)).OfType<ISymbolInitializerOperation>().FirstOrDefault(); |
|||
|
|||
if (operation == null) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var operationValue = operation.Value; |
|||
|
|||
while (operationValue is IConversionOperation conversion) |
|||
{ |
|||
operationValue = conversion.Operand; |
|||
} |
|||
|
|||
switch (operationValue) |
|||
{ |
|||
case IInvocationOperation invocation: |
|||
RegisterInitializer_Invocation(tuple.getInits(operation), invocation, tuple.symbol); |
|||
break; |
|||
case IFieldReferenceOperation fieldRef when IsValidAvaloniaPropertyStorage(fieldRef.Field): |
|||
fieldInitializations[fieldRef.Field] = tuple.symbol; |
|||
break; |
|||
case IPropertyReferenceOperation propRef when IsValidAvaloniaPropertyStorage(propRef.Property): |
|||
fieldInitializations[propRef.Property] = tuple.symbol; |
|||
break; |
|||
} |
|||
} |
|||
}); |
|||
|
|||
// we have recorded every Register and AddOwner call. Now follow assignment chains.
|
|||
foreach (var root in fieldInitializations.Keys.Intersect(_avaloniaProperyDescriptions.Keys, SymbolEqualityComparer.Default).ToArray()) |
|||
{ |
|||
var propertyDescription = _avaloniaProperyDescriptions[root]; |
|||
var owner = propertyDescription.AssignedTo[root]; |
|||
|
|||
var current = root; |
|||
do |
|||
{ |
|||
var target = fieldInitializations[current]; |
|||
|
|||
propertyDescription.AssignedTo[target] = owner; // This loop handles simple assignment operations, so do NOT change the owner
|
|||
_avaloniaProperyDescriptions[target] = propertyDescription; |
|||
|
|||
fieldInitializations.TryGetValue(target, out current); |
|||
} |
|||
while(current != null); |
|||
} |
|||
} |
|||
|
|||
private void RegisterInitializer_Invocation(IEnumerable<ISymbol> initializedSymbols, IInvocationOperation invocation, ISymbol target) |
|||
{ |
|||
try |
|||
{ |
|||
if (invocation.TargetMethod.ReturnType is not INamedTypeSymbol propertyType) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (_avaloniaPropertyRegisterMethods.Contains(invocation.TargetMethod.OriginalDefinition)) // This is a call to one of the AvaloniaProperty.Register* methods
|
|||
{ |
|||
if (!invocation.TargetMethod.IsGenericMethod) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var typeParamLookup = invocation.TargetMethod.TypeParameters.Select((s, i) => (param: s, index: i)) |
|||
.ToDictionary(t => t.param.Name, t => (INamedTypeSymbol)invocation.TargetMethod.TypeArguments[t.index]); |
|||
|
|||
if (!typeParamLookup.TryGetValue("TOwner", out var ownerType) && // if it's NOT a generic parameter, try to work out the runtime value
|
|||
invocation.TargetMethod.Parameters.FirstOrDefault(p => p.Name == "ownerType") is INamedTypeSymbol ownerTypeParam && |
|||
invocation.Arguments.FirstOrDefault(a => SymbolEquals(a.Parameter, ownerTypeParam)) is IArgumentOperation argument) |
|||
{ |
|||
switch (argument.Value) |
|||
{ |
|||
case ITypeOfOperation typeOf: |
|||
ownerType = (INamedTypeSymbol)typeOf.Type!; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (ownerType == null || !typeParamLookup.TryGetValue("TValue", out var propertyValueType)) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
foreach (var symbol in initializedSymbols) |
|||
{ |
|||
string name; |
|||
switch (invocation.Arguments[0].Value) |
|||
{ |
|||
case INameOfOperation nameof when nameof.Argument is IPropertyReferenceOperation propertyReference: |
|||
name = propertyReference.Property.Name; |
|||
break; |
|||
case IAssignmentOperation assignment when assignment.ConstantValue is { HasValue: true } stringLiteral: |
|||
name = (string)stringLiteral.Value!; |
|||
break; |
|||
default: |
|||
return; |
|||
} |
|||
|
|||
var description = _avaloniaProperyDescriptions.GetOrAdd(symbol, s => new AvaloniaPropertyDescription(name, propertyType, propertyValueType)); |
|||
description.Name = name; |
|||
description.AssignedTo[symbol] = ownerType; |
|||
description.OwnerTypes.Add(ownerType); |
|||
} |
|||
} |
|||
else if (_avaloniaPropertyAddOwnerMethods.Contains(invocation.TargetMethod.OriginalDefinition)) // This is a call to one of the AddOwner methods
|
|||
{ |
|||
if (invocation.TargetMethod.TypeArguments[0] is not INamedTypeSymbol ownerType) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
ISymbol sourceSymbol; |
|||
switch (invocation.Instance) |
|||
{ |
|||
case IFieldReferenceOperation fieldReference: |
|||
sourceSymbol = fieldReference.Field; |
|||
break; |
|||
case IPropertyReferenceOperation propertyReference: |
|||
sourceSymbol = propertyReference.Property; |
|||
break; |
|||
default: |
|||
return; |
|||
} |
|||
|
|||
var propertyValueType = AvaloniaPropertyType_GetValueType(propertyType); |
|||
|
|||
foreach (var symbol in initializedSymbols) |
|||
{ |
|||
var description = _avaloniaProperyDescriptions.GetOrAdd(symbol, s => |
|||
{ |
|||
string inferredName = target.Name; |
|||
|
|||
var match = Regex.Match(target.Name, "(?<name>.*)Property$"); |
|||
if (match.Success) |
|||
{ |
|||
inferredName = match.Groups["name"].Value; |
|||
} |
|||
return new AvaloniaPropertyDescription(inferredName, (INamedTypeSymbol)invocation.TargetMethod.ReturnType, propertyValueType); |
|||
}); |
|||
|
|||
description.AssignedTo[symbol] = ownerType; |
|||
description.OwnerTypes.Add(ownerType); |
|||
} |
|||
} |
|||
} |
|||
catch (Exception ex) |
|||
{ |
|||
throw new AvaloniaAnalysisException($"Failed to register the initializer of '{target}'.", ex); |
|||
} |
|||
} |
|||
|
|||
private void AnalyzeFieldInitializer(OperationAnalysisContext context) |
|||
{ |
|||
var operation = (IFieldInitializerOperation)context.Operation; |
|||
|
|||
foreach (var field in operation.InitializedFields) |
|||
{ |
|||
try |
|||
{ |
|||
if (!_avaloniaProperyDescriptions.TryGetValue(field, out var description)) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
if (!IsValidAvaloniaPropertyStorage(field)) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(InappropriatePropertyAssignment, field.Locations[0], field)); |
|||
} |
|||
|
|||
AnalyzeInitializer_Shared(context, field, description); |
|||
|
|||
} |
|||
catch (Exception ex) |
|||
{ |
|||
throw new AvaloniaAnalysisException($"Failed to process initialization of field '{field}'.", ex); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void AnalyzePropertyInitializer(OperationAnalysisContext context) |
|||
{ |
|||
var operation = (IPropertyInitializerOperation)context.Operation; |
|||
|
|||
foreach (var property in operation.InitializedProperties) |
|||
{ |
|||
try |
|||
{ |
|||
if (!_avaloniaProperyDescriptions.TryGetValue(property, out var description)) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
if (!IsValidAvaloniaPropertyStorage(property)) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(InappropriatePropertyAssignment, property.Locations[0], property)); |
|||
} |
|||
|
|||
AnalyzeInitializer_Shared(context, property, description); |
|||
} |
|||
catch (Exception ex) |
|||
{ |
|||
throw new AvaloniaAnalysisException($"Failed to process initialization of property '{property}'.", ex); |
|||
} |
|||
} |
|||
} |
|||
|
|||
private void AnalyzeInitializer_Shared(OperationAnalysisContext context, ISymbol assignmentSymbol, AvaloniaPropertyDescription description) |
|||
{ |
|||
if (!assignmentSymbol.Name.Contains(description.Name)) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(PropertyNameMismatch, assignmentSymbol.Locations[0], |
|||
description.Name, assignmentSymbol)); |
|||
} |
|||
|
|||
try |
|||
{ |
|||
var ownerType = description.AssignedTo[assignmentSymbol]; |
|||
|
|||
if (!IsAvaloniaPropertyType(description.PropertyType, _attachedPropertyType) && !SymbolEquals(ownerType, assignmentSymbol.ContainingType)) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(OwnerDoesNotMatchOuterType, assignmentSymbol.Locations[0], ownerType)); |
|||
} |
|||
} |
|||
catch (KeyNotFoundException) |
|||
{ |
|||
return; // WIP
|
|||
throw new KeyNotFoundException($"Assignment operation for {assignmentSymbol} was not recorded."); |
|||
} |
|||
} |
|||
|
|||
private void StartPropertySymbolAnalysis(SymbolStartAnalysisContext context) |
|||
{ |
|||
var property = (IPropertySymbol)context.Symbol; |
|||
try |
|||
{ |
|||
var avaloniaPropertyDescriptions = GetAvaloniaPropertiesForType(property.ContainingType).ToLookup(d => d.Name); |
|||
|
|||
var candidateTargetProperties = avaloniaPropertyDescriptions[property.Name].ToImmutableArray(); |
|||
|
|||
switch (candidateTargetProperties.Length) |
|||
{ |
|||
case 0: |
|||
return; // does not refer to an AvaloniaProperty
|
|||
case 1: |
|||
candidateTargetProperties[0].PropertyWrappers.Add(property); |
|||
break; |
|||
} |
|||
|
|||
_clrPropertyToAvaloniaProperties[property] = candidateTargetProperties; |
|||
|
|||
context.RegisterSymbolEndAction(context => |
|||
{ |
|||
if (candidateTargetProperties.Length > 1) |
|||
{ |
|||
var candidateSymbols = candidateTargetProperties.Select(d => d.ClosestAssignmentFor(property.ContainingType)).Where(s => s != null); |
|||
context.ReportDiagnostic(Diagnostic.Create(AmbiguousPropertyName, property.Locations[0], candidateSymbols.SelectMany(s => s!.Locations), |
|||
property.ContainingType, property.Name, $"\n\t{string.Join("\n\t", candidateSymbols)}")); |
|||
return; |
|||
} |
|||
|
|||
var avaloniaPropertyDescription = candidateTargetProperties[0]; |
|||
var avaloniaPropertyStorage = avaloniaPropertyDescription.ClosestAssignmentFor(property.ContainingType); |
|||
|
|||
if (avaloniaPropertyStorage == null) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
context.ReportDiagnostic(Diagnostic.Create(AssociatedAvaloniaProperty, property.Locations[0], new[] { avaloniaPropertyStorage.Locations[0] }, |
|||
avaloniaPropertyDescription.PropertyType.Name, avaloniaPropertyStorage)); |
|||
|
|||
if (!SymbolEquals(property.Type, avaloniaPropertyDescription.ValueType, includeNullability: true)) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(PropertyTypeMismatch, property.Locations[0], |
|||
avaloniaPropertyStorage, $"\t\n{string.Join("\t\n", avaloniaPropertyDescription.ValueType, property.Type)}")); |
|||
} |
|||
|
|||
if (property.DeclaredAccessibility != avaloniaPropertyStorage.DeclaredAccessibility) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(InconsistentAccessibility, property.Locations[0], "property", avaloniaPropertyStorage)); |
|||
} |
|||
|
|||
VerifyAccessor(property.GetMethod, "readable", "get"); |
|||
|
|||
if (!IsAvaloniaPropertyType(avaloniaPropertyDescription.PropertyType, _directPropertyType)) |
|||
{ |
|||
VerifyAccessor(property.SetMethod, "writeable", "set"); |
|||
} |
|||
|
|||
void VerifyAccessor(IMethodSymbol? method, string verb, string methodName) |
|||
{ |
|||
if (method == null) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(MissingAccessor, property.Locations[0], avaloniaPropertyStorage, verb, methodName)); |
|||
} |
|||
else if (method.DeclaredAccessibility != avaloniaPropertyStorage.DeclaredAccessibility && method.DeclaredAccessibility != property.DeclaredAccessibility) |
|||
{ |
|||
context.ReportDiagnostic(Diagnostic.Create(InconsistentAccessibility, method.Locations[0], "property accessor", avaloniaPropertyStorage)); |
|||
} |
|||
} |
|||
}); |
|||
} |
|||
catch (Exception ex) |
|||
{ |
|||
throw new AvaloniaAnalysisException($"Failed to analyse property '{property}'.", ex); |
|||
} |
|||
} |
|||
|
|||
private void AnalyzePropertyMethods(CodeBlockAnalysisContext context) |
|||
{ |
|||
if (context.OwningSymbol is not IMethodSymbol { AssociatedSymbol: IPropertySymbol property } method) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
try |
|||
{ |
|||
if (!_clrPropertyToAvaloniaProperties.TryGetValue(property, out var candidateTargetProperties) || |
|||
candidateTargetProperties.Length != 1) // a diagnostic about multiple candidates will have already been reported
|
|||
{ |
|||
return; |
|||
} |
|||
|
|||
var avaloniaPropertyDescription = candidateTargetProperties.Single(); |
|||
|
|||
if (IsAvaloniaPropertyType(avaloniaPropertyDescription.PropertyType, _directPropertyType)) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (!SymbolEquals(property.Type, avaloniaPropertyDescription.ValueType)) |
|||
{ |
|||
return; // a diagnostic about this will have already been reported, and if the cast is implicit then this message would be confusing anyway
|
|||
} |
|||
|
|||
var bodyNode = context.CodeBlock.ChildNodes().Single(); |
|||
|
|||
var operation = bodyNode.DescendantNodes() |
|||
.Where(n => n.IsKind(SyntaxKind.InvocationExpression)) // this line is specific to C#
|
|||
.Select(n => (IInvocationOperation)context.SemanticModel.GetOperation(n)!) |
|||
.FirstOrDefault(); |
|||
|
|||
var isGetMethod = method.MethodKind == MethodKind.PropertyGet; |
|||
|
|||
var expectedInvocations = isGetMethod ? _getValueMethods : _setValueMethods; |
|||
|
|||
if (operation == null || bodyNode.ChildNodes().Count() != 1 || !expectedInvocations.Contains(operation.TargetMethod.OriginalDefinition)) |
|||
{ |
|||
ReportSideEffects(); |
|||
return; |
|||
} |
|||
|
|||
if (operation.Arguments.Length != 0) |
|||
{ |
|||
var argumentValue = operation.Arguments[0].Value; |
|||
if (argumentValue is IConversionOperation conversion) |
|||
{ |
|||
argumentValue = conversion.Operand; |
|||
} |
|||
|
|||
switch (argumentValue) |
|||
{ |
|||
case IFieldReferenceOperation fieldRef when avaloniaPropertyDescription.AssignedTo.ContainsKey(fieldRef.Field): |
|||
case IPropertyReferenceOperation propertyRef when avaloniaPropertyDescription.AssignedTo.ContainsKey(propertyRef.Property): |
|||
break; // the argument is a reference to the correct AvaloniaProperty object
|
|||
default: |
|||
ReportSideEffects(argumentValue.Syntax.GetLocation()); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
if (!isGetMethod && |
|||
operation.Arguments.Length >= 2 && |
|||
operation.Arguments[1].Value.Kind != OperationKind.ParameterReference) // passing something other than `value` to SetValue
|
|||
{ |
|||
ReportSideEffects(operation.Arguments[1].Syntax.GetLocation()); |
|||
} |
|||
|
|||
void ReportSideEffects(Location? locationOverride = null) |
|||
{ |
|||
var propertySourceName = avaloniaPropertyDescription.ClosestAssignmentFor(method.ContainingType)?.Name ?? "[unknown]"; |
|||
|
|||
context.ReportDiagnostic(Diagnostic.Create(AccessorSideEffects, locationOverride ?? context.CodeBlock.GetLocation(), |
|||
avaloniaPropertyDescription.Name, |
|||
isGetMethod ? "read" : "written to", |
|||
isGetMethod ? "get" : "set", |
|||
isGetMethod ? $"GetValue({propertySourceName})" : $"SetValue({propertySourceName}, value)")); |
|||
} |
|||
} |
|||
catch (Exception ex) |
|||
{ |
|||
throw new AvaloniaAnalysisException($"Failed to process property accessor '{method}'.", ex); |
|||
} |
|||
} |
|||
|
|||
private INamedTypeSymbol AvaloniaPropertyType_GetValueType(INamedTypeSymbol type) |
|||
{ |
|||
var compareType = type.IsGenericType ? type.ConstructUnboundGenericType().OriginalDefinition : type; |
|||
|
|||
if (SymbolEquals(compareType, _styledPropertyType) || SymbolEquals(compareType, _attachedPropertyType)) |
|||
{ |
|||
return (INamedTypeSymbol)type.TypeArguments[0]; |
|||
} |
|||
else if (SymbolEquals(compareType, _directPropertyType)) |
|||
{ |
|||
return (INamedTypeSymbol)type.TypeArguments[1]; |
|||
} |
|||
|
|||
throw new ArgumentException($"{type} is not a recognised AvaloniaProperty ({_styledPropertyType}, {_attachedPropertyType}, {_directPropertyType}).", nameof(type)); |
|||
} |
|||
|
|||
private ImmutableHashSet<AvaloniaPropertyDescription> GetAvaloniaPropertiesForType(ITypeSymbol type) |
|||
{ |
|||
var properties = new List<AvaloniaPropertyDescription>(); |
|||
|
|||
var current = type; |
|||
while (current != null) |
|||
{ |
|||
properties.AddRange(current.GetMembers().Intersect(_avaloniaProperyDescriptions.Keys, SymbolEqualityComparer.Default).Select(s => _avaloniaProperyDescriptions[s])); |
|||
current = current.BaseType; |
|||
} |
|||
|
|||
return properties.ToImmutableHashSet(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,253 @@ |
|||
using System; |
|||
using System.Collections.Concurrent; |
|||
using System.Collections.Immutable; |
|||
using System.Linq; |
|||
using System.Runtime.Serialization; |
|||
using Microsoft.CodeAnalysis; |
|||
using Microsoft.CodeAnalysis.Diagnostics; |
|||
|
|||
namespace Avalonia.Analyzers; |
|||
|
|||
[DiagnosticAnalyzer(LanguageNames.CSharp, LanguageNames.VisualBasic)] |
|||
public partial class AvaloniaPropertyAnalyzer : DiagnosticAnalyzer |
|||
{ |
|||
private const string Category = "AvaloniaProperty"; |
|||
|
|||
private const string TypeMismatchTag = "TypeMismatch"; |
|||
private const string NameCollisionTag = "NameCollision"; |
|||
private const string AssociatedPropertyTag = "AssociatedProperty"; |
|||
|
|||
private static readonly DiagnosticDescriptor AssociatedAvaloniaProperty = new( |
|||
"AVP0001", |
|||
"Identify the AvaloniaProperty associated with a CLR property", |
|||
"Associated AvaloniaProperty: {0} {1}", |
|||
Category, |
|||
DiagnosticSeverity.Info, |
|||
isEnabledByDefault: false, |
|||
"This informational diagnostic identifies which AvaloniaProperty a CLR property is associated with.", |
|||
AssociatedPropertyTag); |
|||
|
|||
private static readonly DiagnosticDescriptor InappropriatePropertyAssignment = new( |
|||
"AVP1000", |
|||
"Store AvaloniaProperty objects appropriately", |
|||
"Incorrect AvaloniaProperty storage: {0} should be static and readonly", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"AvaloniaProperty objects have static lifetimes and should be stored accordingly. Do not multiply construct the same property."); |
|||
|
|||
private static readonly DiagnosticDescriptor OwnerDoesNotMatchOuterType = new( |
|||
"AVP1010", |
|||
"Avaloniaproperty objects should declare their owner to be the type in which they are stored", |
|||
"Type mismatch: AvaloniaProperty owner is {0}, which is not the containing type", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"The owner of an AvaloniaProperty should generally be the containing type. This ensures that the property can be used as expected in XAML.", |
|||
TypeMismatchTag); |
|||
|
|||
private static readonly DiagnosticDescriptor DuplicatePropertyName = new( |
|||
"AVP1020", |
|||
"AvaloniaProperty names should be unique within each class", |
|||
"Name collision: {0} has the same name as {1}", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"Querying for an AvaloniaProperty by name requires that each property associated with a type have a unique name.", |
|||
NameCollisionTag); |
|||
|
|||
private static readonly DiagnosticDescriptor AmbiguousPropertyName = new( |
|||
"AVP1021", |
|||
"Ensure an umabiguous relationship between CLR properties and Avalonia properties within the same class", |
|||
"Name collision: {0} owns multiple Avalonia properties with the name '{1}' {2}", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"It is unclear which AvaloniaProperty this CLR property refers to. Ensure that each AvaloniaProperty associated with a type has a unique name. If you need to change behaviour of a base property in your class, call its AddOwner method and provide new metadata.", |
|||
NameCollisionTag); |
|||
|
|||
private static readonly DiagnosticDescriptor PropertyNameMismatch = new( |
|||
"AVP1022", |
|||
"Store each AvaloniaProperty object in a field or CLR property which reflects its name", |
|||
"Bad name: An AvaloniaProperty named '{0}' is being assigned to {1}. These names do not relate.", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"An AvaloniaProperty should be stored in a field or property which contains its name. For example, a property named \"Brush\" should be assigned to a field called \"BrushProperty\".", |
|||
NameCollisionTag); |
|||
|
|||
private static readonly DiagnosticDescriptor AccessorSideEffects = new( |
|||
"AVP1030", |
|||
"Do not add side effects to StyledProperty accessors", |
|||
"Side effects: '{0}' is an AvaloniaProperty which can be {1} without the use of this CLR property. This {2} accessor should do nothing except call {3}.", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"The AvaloniaObject.GetValue and AvaloniaObject.SetValue methods are public, and do not call any user CLR properties. To execute code before or after the property is set, create a Coerce method or a PropertyChanged subscriber.", |
|||
AssociatedPropertyTag); |
|||
|
|||
private static readonly DiagnosticDescriptor MissingAccessor = new( |
|||
"AVP1031", |
|||
"A CLR property should support the same get/set operations as its associated AvaloniaProperty", |
|||
"Missing accessor: {0} is {1}, but this CLR property lacks a {2} accessor", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"The AvaloniaObject.GetValue and AvaloniaObject.SetValue methods are public, and do not call CLR properties on the owning type. Not providing both CLR property accessors is ineffective.", |
|||
AssociatedPropertyTag); |
|||
|
|||
private static readonly DiagnosticDescriptor InconsistentAccessibility = new( |
|||
"AVP1032", |
|||
"A CLR property and its accessors should be equally accessible as its associated AvaloniaProperty", |
|||
"Inconsistent accessibility: CLR {0} accessiblity does not match accessibility of {1}", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"The AvaloniaObject.GetValue and AvaloniaObject.SetValue methods are public, and do not call CLR properties on the owning type. Defining a CLR property with different acessibility from its associated AvaloniaProperty is ineffective.", |
|||
AssociatedPropertyTag); |
|||
|
|||
private static readonly DiagnosticDescriptor PropertyTypeMismatch = new( |
|||
"AVP1040", |
|||
"CLR property type should match associated AvaloniaProperty type", |
|||
"Type mismatch: CLR property type differs from the value type of {0} {1}", |
|||
Category, |
|||
DiagnosticSeverity.Warning, |
|||
isEnabledByDefault: true, |
|||
"The AvaloniaObject.GetValue and AvaloniaObject.SetValue methods are public, and do not call CLR properties on the owning type. A CLR property changing the value type (even when an implicit cast is possible) is ineffective and can lead to InvalidCastException to be thrown.", |
|||
TypeMismatchTag, AssociatedPropertyTag); |
|||
|
|||
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create( |
|||
AssociatedAvaloniaProperty, |
|||
InappropriatePropertyAssignment, |
|||
OwnerDoesNotMatchOuterType, |
|||
DuplicatePropertyName, |
|||
AmbiguousPropertyName, |
|||
PropertyNameMismatch, |
|||
AccessorSideEffects, |
|||
MissingAccessor, |
|||
InconsistentAccessibility, |
|||
PropertyTypeMismatch); |
|||
|
|||
public override void Initialize(AnalysisContext context) |
|||
{ |
|||
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); |
|||
context.EnableConcurrentExecution(); |
|||
|
|||
context.RegisterCompilationStartAction(c => new CompileAnalyzer(c)); |
|||
} |
|||
|
|||
private static bool IsAvaloniaPropertyType(INamedTypeSymbol type, params INamedTypeSymbol[] propertyTypes) |
|||
{ |
|||
if (type.IsGenericType) |
|||
{ |
|||
type = type.ConstructUnboundGenericType().OriginalDefinition; |
|||
} |
|||
|
|||
return propertyTypes.Any(t => SymbolEquals(type, t)); |
|||
} |
|||
|
|||
private static bool DerivesFrom(ITypeSymbol? type, ITypeSymbol baseType) |
|||
{ |
|||
while (type != null) |
|||
{ |
|||
if (SymbolEquals(type, baseType)) |
|||
{ |
|||
return true; |
|||
} |
|||
|
|||
type = type.BaseType; |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private static bool IsValidAvaloniaPropertyStorage(IFieldSymbol field) => field.IsStatic && field.IsReadOnly; |
|||
private static bool IsValidAvaloniaPropertyStorage(IPropertySymbol field) => field.IsStatic && field.IsReadOnly; |
|||
|
|||
private static bool SymbolEquals(ISymbol? x, ISymbol? y, bool includeNullability = false) |
|||
{ |
|||
// The current version of Microsoft.CodeAnalysis includes an "IncludeNullability" comparer,
|
|||
// but it overshoots the target and tries to compare EVERYTHING. This leads to two symbols for
|
|||
// the same type not being equal if they were imported into different compile units (i.e. assemblies).
|
|||
// So for now, we will just discard this parameter.
|
|||
_ = includeNullability; |
|||
|
|||
return SymbolEqualityComparer.Default.Equals(x, y); |
|||
} |
|||
|
|||
private class AvaloniaPropertyDescription |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the name that was assigned to this property when it was registered.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// If the property was not registered within the current compile context, this value will be inferred from
|
|||
/// the name of the field (or CLR property) in which the AvaloniaProperty object is stored.
|
|||
/// </remarks>
|
|||
public string Name { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the type of the AvaloniaProperty itself: Styled, Direct, or Attached
|
|||
/// </summary>
|
|||
public INamedTypeSymbol PropertyType { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the TValue type that the property stores.
|
|||
/// </summary>
|
|||
public INamedTypeSymbol ValueType { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the type which registered the property, and all types which have added themselves as owners.
|
|||
/// </summary>
|
|||
public ConcurrentBag<INamedTypeSymbol> OwnerTypes { get; } = new(); |
|||
|
|||
/// <summary>
|
|||
/// Gets a dictionary which maps fields and properties which were initialized with this AvaloniaProperty to the TOwner specified at each assignment.
|
|||
/// </summary>
|
|||
public ConcurrentDictionary<ISymbol, INamedTypeSymbol> AssignedTo { get; } = new(SymbolEqualityComparer.Default); |
|||
|
|||
/// <summary>
|
|||
/// Gets properties which provide convenient access to the AvaloniaProperty on an instance of an AvaloniaObject.
|
|||
/// </summary>
|
|||
public ConcurrentBag<IPropertySymbol> PropertyWrappers { get; } = new(); |
|||
|
|||
public AvaloniaPropertyDescription(string name, INamedTypeSymbol propertyType, INamedTypeSymbol valueType) |
|||
{ |
|||
Name = name; |
|||
PropertyType = propertyType; |
|||
ValueType = valueType; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Searches the inheritance hierarchy of the given type for a field or property to which this AvaloniaProperty is assigned.
|
|||
/// </summary>
|
|||
public ISymbol? ClosestAssignmentFor(ITypeSymbol? type) |
|||
{ |
|||
var assignmentsByType = AssignedTo.Keys.ToLookup(s => s.ContainingType, SymbolEqualityComparer.Default); |
|||
|
|||
while (type != null) |
|||
{ |
|||
if (assignmentsByType.Contains(type)) |
|||
{ |
|||
return assignmentsByType[type].First(); |
|||
} |
|||
type = type.BaseType; |
|||
} |
|||
|
|||
return null; |
|||
} |
|||
} |
|||
|
|||
} |
|||
|
|||
[Serializable] |
|||
public class AvaloniaAnalysisException : Exception |
|||
{ |
|||
public AvaloniaAnalysisException(string message, Exception? innerException = null) : base(message, innerException) |
|||
{ |
|||
} |
|||
|
|||
protected AvaloniaAnalysisException(SerializationInfo info, StreamingContext context) : base(info, context) |
|||
{ |
|||
} |
|||
} |
|||
Loading…
Reference in new issue