< Summary

Information
Class: MyNet.Observable.Metadata.Generator.MetadataProviderGenerator
Assembly: MyNet.Observable.Metadata.Generator
File(s): https://raw.githubusercontent.com/sandre58/MyNet/5aaaab311aa14541478b9e402357d98b657a23e4/src/MyNet.Observable.Metadata.Generator/MetadataProviderGenerator.cs
Tag: 342_31701152804
Line coverage
86%
Covered lines: 179
Uncovered lines: 29
Coverable lines: 208
Total lines: 423
Line coverage: 86%
Branch coverage
70%
Covered branches: 75
Total branches: 106
Branch coverage: 70.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
Initialize(...)100%11100%
HasEnforceGeneratedMetadataAttribute(...)100%11100%
GetTypeModel(...)70%101088.88%
BuildPropertyModel(...)68.75%1616100%
TryApplyFeatureAttribute(...)42.85%531441.66%
TryApplyBehaviorAttribute(...)41.66%431240%
Emit(...)100%44100%
ReportMissingMetadata(...)93.75%161693.75%
InheritsFrom(...)100%44100%
EnumerateNamedTypes()87.5%8888.88%
EnumerateNestedTypes()25%9433.33%
EmitMetadataBootstrap(...)100%44100%
GetConfigureMethodName(...)100%11100%
EmitTypeConfigurationMethod(...)100%22100%
EmitPropertyConfiguration(...)75%141275%

File(s)

https://raw.githubusercontent.com/sandre58/MyNet/5aaaab311aa14541478b9e402357d98b657a23e4/src/MyNet.Observable.Metadata.Generator/MetadataProviderGenerator.cs

#LineLine coverage
 1// -----------------------------------------------------------------------
 2// <copyright file="MetadataProviderGenerator.cs" company="Stéphane ANDRE">
 3// Copyright (c) Stéphane ANDRE. All rights reserved.
 4// </copyright>
 5// -----------------------------------------------------------------------
 6
 7using System;
 8using System.Collections.Generic;
 9using System.Collections.Immutable;
 10using System.Diagnostics.CodeAnalysis;
 11using System.Linq;
 12using System.Text;
 13using Microsoft.CodeAnalysis;
 14using Microsoft.CodeAnalysis.CSharp.Syntax;
 15using Microsoft.CodeAnalysis.Text;
 16
 17namespace MyNet.Observable.Metadata.Generator;
 18
 19[Generator(LanguageNames.CSharp)]
 20public sealed class MetadataProviderGenerator : IIncrementalGenerator
 21{
 22    private const string IgnoreModificationTrackingAttribute = "MyNet.Observable.Behaviors.Metadata.Attributes.IgnoreMod
 23    private const string UpdateOnCultureChangedAttribute = "MyNet.Observable.Behaviors.Metadata.Attributes.UpdateOnCultu
 24    private const string UpdateOnTimeZoneChangedAttribute = "MyNet.Observable.Behaviors.Metadata.Attributes.UpdateOnTime
 25    private const string AlsoValidateAttribute = "MyNet.Observable.Behaviors.Metadata.Attributes.AlsoValidateAttribute";
 26
 27    // Behavior-related property attributes
 28    private const string ForwardPropertyAttribute = "MyNet.Observable.Behaviors.Metadata.Attributes.ForwardPropertyAttri
 29    private const string EnforceGeneratedMetadataAttribute = "MyNet.Observable.Metadata.EnforceGeneratedMetadataAttribut
 30    private const string ExemptFromGeneratedMetadataAttribute = "MyNet.Observable.Metadata.ExemptFromGeneratedMetadataAt
 31    private const string ObservableObjectType = "MyNet.Observable.ObservableObject";
 32
 333    private static readonly DiagnosticDescriptor MissingProviderDescriptor = new(
 334        id: "MNETMETA001",
 335        title: "Generated metadata configuration is missing",
 336        messageFormat: "Type '{0}' derives from ObservableObject but has no generated metadata configuration. Add metada
 337        category: "MyNet.Observable.Metadata.Generator",
 338        defaultSeverity: DiagnosticSeverity.Error,
 339        isEnabledByDefault: true);
 40
 41    public void Initialize(IncrementalGeneratorInitializationContext context)
 42    {
 43        // Check for strict mode assembly attribute
 2744        var enforceMetadata = context.CompilationProvider
 2745            .Select(static (compilation, _) => HasEnforceGeneratedMetadataAttribute(compilation));
 46
 2747        var candidates = context.SyntaxProvider
 2748            .CreateSyntaxProvider(
 2749                static (node, _) => node is ClassDeclarationSyntax,
 2750                static (ctx, _) => GetTypeModel(ctx))
 2751            .Where(static model => model is not null)
 2752            .Select(static (model, _) => model!);
 53
 2754        context.RegisterSourceOutput(
 2755            candidates.Collect().Combine(enforceMetadata).Combine(context.CompilationProvider),
 2756            static (spc, data) => Emit(spc, data.Left.Left, data.Left.Right, data.Right));
 2757    }
 58
 59    private static bool HasEnforceGeneratedMetadataAttribute(Compilation compilation)
 2760        => compilation.Assembly.GetAttributes()
 2761            .Any(attr => attr.AttributeClass?.ToDisplayString() == EnforceGeneratedMetadataAttribute);
 62
 63    private static TypeModel? GetTypeModel(GeneratorSyntaxContext context)
 64    {
 3365        if (context.Node is not ClassDeclarationSyntax classSyntax)
 066            return null;
 67
 3368        if (context.SemanticModel.GetDeclaredSymbol(classSyntax) is not INamedTypeSymbol typeSymbol)
 069            return null;
 70
 3371        var observableObjectSymbol = context.SemanticModel.Compilation.GetTypeByMetadataName(ObservableObjectType);
 3372        if (observableObjectSymbol is null || !InheritsFrom(typeSymbol, observableObjectSymbol))
 673            return null;
 74
 2775        var properties =
 2776            (from property in typeSymbol.GetMembers().OfType<IPropertySymbol>()
 2777             where !property.IsStatic
 2778             let model = BuildPropertyModel(property)
 2779             where model is not null
 2780             select model)
 2781            .ToImmutableArray();
 82
 2783        if (properties.Length == 0)
 984            return null;
 85
 1886        var fullyQualifiedTypeName = typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 87
 1888        return new TypeModel(fullyQualifiedTypeName, properties);
 89    }
 90
 91    [SuppressMessage("ReSharper", "MergeIntoPattern", Justification = "Improves readability in this case")]
 92    private static PropertyModel? BuildPropertyModel(IPropertySymbol property)
 93    {
 2194        var ignoreTracking = false;
 2195        var reactsToCulture = false;
 2196        var reactsToTimeZone = false;
 2197        var propertyChangedForwarding = false;
 2198        var concatenateForwardedPropertyName = true;
 2199        var validationDependents = ImmutableArray<string>.Empty;
 100
 42101        foreach (var attributeName in from attribute in property.GetAttributes() let attributeName = attribute.Attribute
 102        {
 103            switch (attributeName)
 104            {
 105                default:
 106                    continue;
 107            }
 108        }
 109
 21110        return !ignoreTracking && !reactsToCulture && !reactsToTimeZone && !propertyChangedForwarding && validationDepen
 21111            ? null
 21112            : new PropertyModel(property.Name, ignoreTracking, reactsToCulture, reactsToTimeZone, propertyChangedForward
 113    }
 114
 115    [SuppressMessage("ReSharper", "MergeIntoPattern", Justification = "Improves readability in this case")]
 116    private static bool TryApplyFeatureAttribute(
 117        string? attributeName,
 118        AttributeData attribute,
 119        ref bool ignoreTracking,
 120        ref bool reactsToCulture,
 121        ref bool reactsToTimeZone,
 122        ref ImmutableArray<string> validationDependents)
 123    {
 124        switch (attributeName)
 125        {
 126            case IgnoreModificationTrackingAttribute:
 3127                ignoreTracking = true;
 3128                return true;
 129            case UpdateOnCultureChangedAttribute:
 12130                reactsToCulture = true;
 12131                return true;
 132            case UpdateOnTimeZoneChangedAttribute:
 0133                reactsToTimeZone = true;
 0134                return true;
 135            case AlsoValidateAttribute:
 0136                if (attribute.ConstructorArguments.Length == 1 &&
 0137                    attribute.ConstructorArguments[0].Value is string dependent &&
 0138                    !string.IsNullOrWhiteSpace(dependent))
 139                {
 0140                    validationDependents = validationDependents.Add(dependent);
 141                }
 142
 0143                return true;
 144            default:
 6145                return false;
 146        }
 147    }
 148
 149    private static bool TryApplyBehaviorAttribute(string? attributeName, AttributeData attribute, ref bool propertyChang
 150    {
 151        switch (attributeName)
 152        {
 153            case ForwardPropertyAttribute:
 6154                propertyChangedForwarding = true;
 155
 6156                if (attribute.ConstructorArguments.Length > 0 && attribute.ConstructorArguments[0].Value is bool ctorVal
 0157                    concatenateForwardedPropertyName = ctorValue;
 158
 12159                foreach (var namedArgument in attribute.NamedArguments)
 160                {
 0161                    if (!string.Equals(namedArgument.Key, "ConcatenatePropertyName", StringComparison.Ordinal) ||
 0162                        namedArgument.Value.Value is not bool namedValue)
 163                    {
 164                        continue;
 165                    }
 166
 0167                    concatenateForwardedPropertyName = namedValue;
 0168                    break;
 169                }
 170
 6171                return true;
 172            default:
 0173                return false;
 174        }
 175    }
 176
 177    private static void Emit(SourceProductionContext context, ImmutableArray<TypeModel> models, bool enforceGeneratedMet
 178    {
 27179        var distinctModels = models
 27180            .GroupBy(static x => x.FullyQualifiedTypeName, StringComparer.Ordinal)
 27181            .Select(static x => x.First())
 27182            .OrderBy(static x => x.FullyQualifiedTypeName, StringComparer.Ordinal)
 27183            .ToArray();
 184
 27185        var source = new StringBuilder();
 27186        source.AppendLine("// <auto-generated />");
 27187        source.AppendLine("#nullable enable");
 27188        source.AppendLine("using System;");
 27189        source.AppendLine("using System.Collections.Concurrent;");
 27190        source.AppendLine("using MyNet.Observable.Behaviors.Metadata;");
 27191        source.AppendLine("using MyNet.Metadata;");
 27192        source.AppendLine();
 27193        source.AppendLine("namespace MyNet.Metadata.Generated");
 27194        source.AppendLine("{");
 195
 196        // Generate fluent metadata configuration class
 27197        if (distinctModels.Length > 0)
 198        {
 18199            EmitMetadataBootstrap(source, distinctModels);
 200        }
 201
 27202        source.AppendLine("}");
 203
 27204        context.AddSource("GeneratedMetadataProviders.g.cs", SourceText.From(source.ToString(), Encoding.UTF8));
 205
 27206        if (enforceGeneratedMetadata)
 6207            ReportMissingMetadata(context, compilation, distinctModels);
 27208    }
 209
 210    private static void ReportMissingMetadata(SourceProductionContext context, Compilation compilation, TypeModel[] gene
 211    {
 6212        var observableObjectSymbol = compilation.GetTypeByMetadataName(ObservableObjectType);
 6213        if (observableObjectSymbol is null)
 0214            return;
 215
 6216        var generatedTypeNames = new HashSet<string>(
 6217            generatedModels.Select(x => x.FullyQualifiedTypeName),
 6218            StringComparer.Ordinal);
 219
 30220        foreach (var type in EnumerateNamedTypes(compilation.Assembly.GlobalNamespace))
 221        {
 9222            if (type.TypeKind != TypeKind.Class || type.IsAbstract)
 223                continue;
 224
 9225            if (!InheritsFrom(type, observableObjectSymbol))
 226                continue;
 227
 6228            if (type.GetAttributes().Any(attr => attr.AttributeClass?.ToDisplayString() == ExemptFromGeneratedMetadataAt
 229                continue;
 230
 3231            var typeName = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 3232            if (generatedTypeNames.Contains(typeName))
 233                continue;
 234
 3235            var location = type.Locations.FirstOrDefault(static l => l.IsInSource);
 3236            if (location is null)
 237                continue;
 238
 3239            context.ReportDiagnostic(Diagnostic.Create(MissingProviderDescriptor, location, type.ToDisplayString()));
 240        }
 6241    }
 242
 243    private static bool InheritsFrom(INamedTypeSymbol type, INamedTypeSymbol baseType)
 244    {
 192245        for (var current = type; current is not null; current = current.BaseType)
 246        {
 87247            if (SymbolEqualityComparer.Default.Equals(current, baseType))
 33248                return true;
 249        }
 250
 9251        return false;
 252    }
 253
 254    private static IEnumerable<INamedTypeSymbol> EnumerateNamedTypes(INamespaceSymbol ns)
 255    {
 42256        foreach (var type in ns.GetTypeMembers())
 257        {
 9258            yield return type;
 259
 18260            foreach (var nested in EnumerateNestedTypes(type))
 0261                yield return nested;
 9262        }
 263
 36264        foreach (var child in ns.GetNamespaceMembers())
 265        {
 30266            foreach (var type in EnumerateNamedTypes(child))
 9267                yield return type;
 268        }
 12269    }
 270
 271    private static IEnumerable<INamedTypeSymbol> EnumerateNestedTypes(INamedTypeSymbol type)
 272    {
 18273        foreach (var nested in type.GetTypeMembers())
 274        {
 0275            yield return nested;
 276
 0277            foreach (var child in EnumerateNestedTypes(nested))
 0278                yield return child;
 0279        }
 9280    }
 281
 282    private static void EmitMetadataBootstrap(StringBuilder source, TypeModel[] distinctModels)
 283    {
 18284        source.AppendLine();
 18285        source.AppendLine("    internal static class ObservableMetadataBootstrap");
 18286        source.AppendLine("    {");
 18287        source.AppendLine("        private static readonly ConcurrentDictionary<Type, byte> Applied = new();");
 18288        source.AppendLine();
 18289        source.AppendLine("        internal static void Ensure(Type type)");
 18290        source.AppendLine("        {");
 18291        source.AppendLine("            ArgumentNullException.ThrowIfNull(type);");
 18292        source.AppendLine();
 293
 72294        foreach (var model in distinctModels)
 295        {
 18296            source.Append("            if (type == typeof(");
 18297            source.Append(model.FullyQualifiedTypeName);
 18298            source.AppendLine("))");
 18299            source.AppendLine("            {");
 18300            source.Append("                EnsureConfigured(type, ");
 18301            source.Append(GetConfigureMethodName(model.FullyQualifiedTypeName));
 18302            source.AppendLine(");");
 18303            source.AppendLine("                return;");
 18304            source.AppendLine("            }");
 18305            source.AppendLine();
 306        }
 307
 18308        source.AppendLine("        }");
 18309        source.AppendLine();
 18310        source.AppendLine("        private static void EnsureConfigured(Type type, Action configure)");
 18311        source.AppendLine("        {");
 18312        source.AppendLine("            if (Applied.TryAdd(type, 0))");
 18313        source.AppendLine("                configure();");
 18314        source.AppendLine("        }");
 18315        source.AppendLine();
 316
 72317        foreach (var model in distinctModels)
 18318            EmitTypeConfigurationMethod(source, model);
 319
 18320        source.AppendLine("    }");
 18321    }
 322
 323    private static string GetConfigureMethodName(string fullyQualifiedTypeName)
 324    {
 36325        var name = fullyQualifiedTypeName
 36326            .Replace("global::", string.Empty)
 36327            .Replace('.', '_')
 36328            .Replace('<', '_')
 36329            .Replace('>', '_');
 330
 36331        return "Configure_" + name;
 332    }
 333
 334    private static void EmitTypeConfigurationMethod(StringBuilder source, TypeModel model)
 335    {
 18336        var methodName = GetConfigureMethodName(model.FullyQualifiedTypeName);
 18337        source.Append("        private static void ");
 18338        source.Append(methodName);
 18339        source.AppendLine("()");
 18340        source.AppendLine("        {");
 341
 72342        foreach (var property in model.Properties)
 343        {
 18344            EmitPropertyConfiguration(source, model, property);
 345        }
 346
 18347        source.AppendLine("        }");
 18348        source.AppendLine();
 18349    }
 350
 351    private static void EmitPropertyConfiguration(StringBuilder source, TypeModel model, PropertyModel property)
 352    {
 18353        source.Append("            var metadata_");
 18354        source.Append(property.Name);
 18355        source.Append(" = MetadataRegistry.Get(typeof(");
 18356        source.Append(model.FullyQualifiedTypeName);
 18357        source.Append(")).GetProperty(\"");
 18358        source.Append(property.Name);
 18359        source.AppendLine("\");");
 360
 18361        if (property.IgnoreModificationTracking)
 362        {
 3363            source.Append("            MetadataApplicators.ApplyIgnoreModificationTracking(metadata_");
 3364            source.Append(property.Name);
 3365            source.AppendLine(");");
 366        }
 367
 18368        if (property.ReactsToCulture)
 369        {
 12370            source.Append("            MetadataApplicators.ApplyUpdateOnCultureChanged(metadata_");
 12371            source.Append(property.Name);
 12372            source.AppendLine(");");
 373        }
 374
 18375        if (property.ReactsToTimeZone)
 376        {
 0377            source.Append("            MetadataApplicators.ApplyUpdateOnTimeZoneChanged(metadata_");
 0378            source.Append(property.Name);
 0379            source.AppendLine(");");
 380        }
 381
 36382        foreach (var dependent in property.ValidationDependents)
 383        {
 0384            source.Append("            MetadataApplicators.ApplyAlsoValidate(metadata_");
 0385            source.Append(property.Name);
 0386            source.Append(", \"");
 0387            source.Append(dependent.Replace("\"", "\\\""));
 0388            source.AppendLine("\");");
 389        }
 390
 30391        if (!property.PropertyChangedForwarding) return;
 6392        source.Append("            MetadataApplicators.ApplyForwardProperty(metadata_");
 6393        source.Append(property.Name);
 6394        source.Append(", ");
 6395        source.Append(property.ConcatenateForwardedPropertyName ? "true" : "false");
 6396        source.AppendLine(");");
 6397    }
 398
 399    private sealed class TypeModel(string fullyQualifiedTypeName, ImmutableArray<PropertyModel> properties)
 400    {
 401        public string FullyQualifiedTypeName { get; } = fullyQualifiedTypeName;
 402
 403        public ImmutableArray<PropertyModel> Properties { get; } = properties;
 404    }
 405
 406    private sealed class PropertyModel(string name, bool ignoreModificationTracking, bool reactsToCulture, bool reactsTo
 407    {
 408        public string Name { get; } = name;
 409
 410        public bool IgnoreModificationTracking { get; } = ignoreModificationTracking;
 411
 412        public bool ReactsToCulture { get; } = reactsToCulture;
 413
 414        public bool ReactsToTimeZone { get; } = reactsToTimeZone;
 415
 416        public bool PropertyChangedForwarding { get; } = propertyChangedForwarding;
 417
 418        public bool ConcatenateForwardedPropertyName { get; } = concatenateForwardedPropertyName;
 419
 420        public ImmutableArray<string> ValidationDependents { get; } = validationDependents;
 421    }
 422}
 423

Methods/Properties

.cctor()
Initialize(Microsoft.CodeAnalysis.IncrementalGeneratorInitializationContext)
HasEnforceGeneratedMetadataAttribute(Microsoft.CodeAnalysis.Compilation)
GetTypeModel(Microsoft.CodeAnalysis.GeneratorSyntaxContext)
BuildPropertyModel(Microsoft.CodeAnalysis.IPropertySymbol)
TryApplyFeatureAttribute(System.String,Microsoft.CodeAnalysis.AttributeData,System.Boolean&,System.Boolean&,System.Boolean&,System.Collections.Immutable.ImmutableArray`1<System.String>&)
TryApplyBehaviorAttribute(System.String,Microsoft.CodeAnalysis.AttributeData,System.Boolean&,System.Boolean&)
Emit(Microsoft.CodeAnalysis.SourceProductionContext,System.Collections.Immutable.ImmutableArray`1<MyNet.Observable.Metadata.Generator.MetadataProviderGenerator/TypeModel>,System.Boolean,Microsoft.CodeAnalysis.Compilation)
ReportMissingMetadata(Microsoft.CodeAnalysis.SourceProductionContext,Microsoft.CodeAnalysis.Compilation,MyNet.Observable.Metadata.Generator.MetadataProviderGenerator/TypeModel[])
InheritsFrom(Microsoft.CodeAnalysis.INamedTypeSymbol,Microsoft.CodeAnalysis.INamedTypeSymbol)
EnumerateNamedTypes()
EnumerateNestedTypes()
EmitMetadataBootstrap(System.Text.StringBuilder,MyNet.Observable.Metadata.Generator.MetadataProviderGenerator/TypeModel[])
GetConfigureMethodName(System.String)
EmitTypeConfigurationMethod(System.Text.StringBuilder,MyNet.Observable.Metadata.Generator.MetadataProviderGenerator/TypeModel)
EmitPropertyConfiguration(System.Text.StringBuilder,MyNet.Observable.Metadata.Generator.MetadataProviderGenerator/TypeModel,MyNet.Observable.Metadata.Generator.MetadataProviderGenerator/PropertyModel)