public void RunGeneration(INamedTypeSymbol declaredType, CancellationToken ct)
{
if (!TryAnalyze(declaredType, ct, out var exportingSymbol))
{
return;
}
// Generate code
var extension = new CodeExtensionBuilder(declaredType);
var attributeSymbol = SymbolProvider.Source.GetSymbol(AttributeType) as INamedTypeSymbol;
Debug.Assert(attributeSymbol is not null);
if (!exportingSymbol.GetAttributes().Any(x => attributeSymbol.Equals(x.AttributeClass, SymbolEqualityComparer.Default)))
{
extension.Attribute(AddAttribute(attributeSymbol));
}
var generatorHost = SymbolProvider.Source.GetSymbol(HostType) as INamedTypeSymbol;
Debug.Assert(generatorHost is not null);
var hostAbstractSymbol = generatorHost.GetMembers().First(x => x is IPropertySymbol && x.IsAbstract) as IPropertySymbol;
Debug.Assert(hostAbstractSymbol is not null && hostAbstractSymbol.Name == StartupTypeName);
extension.Inherit(generatorHost);
extension.ExtendSymbol(node => {
var overridenProp = exportingSymbol.GetMembers()
.FirstOrDefault(x => x is IPropertySymbol ps &&
ps.OverriddenProperty is not null &&
ps.OverriddenProperty.Equals(hostAbstractSymbol, SymbolEqualityComparer.Default));
if (overridenProp is null)
{
node.State($"protected override {hostAbstractSymbol.Type} {hostAbstractSymbol.Name} {{ get; }} = {declaredType}");
}
// Consider warning the user not to override that, and allow us to handle it
});
_source.AddSource($"{declaredType}.meta.generated", extension.ToString());
}
public IMemberComposer Build(ITypeComposer typeComposer, MemberMetaInfo meta, GeneratingTypeName typeName, IComponentProvider provider)
=> new MemberComposerSource(meta, typeName, _conditions, _formatters, _symbolProvider)
.CreateStruct(typeComposer, provider, (name, source) => {
_sourceAddition.AddSource($"{typeName}.generated.cs", source);
return(_symbolProvider.GetSymbol(name.ToString()));
});
