public void Initialize(IncrementalGeneratorInitializationContext context) { context.RegisterSourceOutput(context.AdditionalTextsProvider, (context, additionalText) => context.AddSource( GetGeneratedFileName(additionalText.Path), GenerateSourceForAdditionalFile(additionalText, context.CancellationToken))); }
public void Initialize(IncrementalGeneratorInitializationContext context) { IncrementalValuesProvider <TypeDeclarationSyntax> providerTypes = context.SyntaxProvider.CreateSyntaxProvider( (node, _) => SyntaxCollector.IsCandidateType(node), (syntaxContext, _) => (TypeDeclarationSyntax)syntaxContext.Node); IncrementalValuesProvider <InvocationExpressionSyntax> getServiceCalls = context.SyntaxProvider.CreateSyntaxProvider( (node, _) => SyntaxCollector.IsGetServiceExpression(node), (syntaxContext, _) => (InvocationExpressionSyntax)syntaxContext.Node); var collectedServiceCalls = getServiceCalls.Collect(); var providers = providerTypes.Combine(collectedServiceCalls).Combine(context.CompilationProvider); context.RegisterSourceOutput(providers, (productionContext, inputs) => Execute(new GeneratorContext( productionContext, ImmutableArray.Create(inputs.Item1.Item1), inputs.Item1.Item2, inputs.Item2))); context.RegisterPostInitializationOutput(c => { c.AddSource("Attributes.cs", ReadAttributesFile()); }); }
public void Initialize(IncrementalGeneratorInitializationContext context) { context.RegisterPostInitializationOutput(PostInitializationCallback); IncrementalValueProvider <ImmutableArray <MethodDeclarationSyntax> > syntaxProvider = context.SyntaxProvider .CreateSyntaxProvider(SyntaxProviderPredicate, SyntaxProviderTransform) .Where(static method => method is not null)
public void Initialize(IncrementalGeneratorInitializationContext context) { var classDeclarations = context.SyntaxProvider.CreateSyntaxProvider( predicate: (s, t) => s is ClassDeclarationSyntax, transform: GetTypeSymbols).Collect(); context.RegisterSourceOutput(classDeclarations, GenerateSource); }
/// <inheritdoc /> public void Initialize(IncrementalGeneratorInitializationContext context) { // Register the attribute source context.RegisterPostInitializationOutput(ctx => ctx.AddSource("TagAttribute.g.cs", Sources.Attributes)); IncrementalValuesProvider <ClassDeclarationSyntax> classDeclarations = context.SyntaxProvider.CreateSyntaxProvider(IsAttributedProperty, GetPotentialClassesForGeneration) .Where(static m => m is not null) !;
public void Initialize(IncrementalGeneratorInitializationContext context) => context.RegisterPostInitializationOutput(ctx => { ctx.AddSource("RequiredPropertiesSourceGen.cs", @" using System; [AttributeUsage(AttributeTargets.Property)] public class RequiredPropertyAttribute: Attribute { }"); });
public void Initialize(IncrementalGeneratorInitializationContext context) { IncrementalValuesProvider <ClassDeclarationSyntax> classDeclarations = context.SyntaxProvider .ForAttributeWithMetadataName( context, Parser.LoggerMessageAttribute, (node, _) => node is MethodDeclarationSyntax, (context, _) => context.TargetNode.Parent as ClassDeclarationSyntax) .Where(static m => m is not null);
public void Initialize(IncrementalGeneratorInitializationContext context) { var syntaxProvider = context.SyntaxProvider.CreateSyntaxProvider( (node, _) => node is StructDeclarationSyntax tds && tds.AttributeLists.ContainsAttribute("StringEnum"), (syntaxContext, _) => syntaxContext ); context.RegisterSourceOutput(syntaxProvider, GenerateEnum); }
public void Initialize(IncrementalGeneratorInitializationContext context) { // Contains one entry per regex method, either the generated code for that regex method, // a diagnostic to fail with, or null if no action should be taken for that regex. IncrementalValueProvider<ImmutableArray<object?>> codeOrDiagnostics = context.SyntaxProvider // Find all MethodDeclarationSyntax nodes attributed with RegexGenerator .CreateSyntaxProvider(static (s, _) => IsSyntaxTargetForGeneration(s), static (ctx, _) => GetSemanticTargetForGeneration(ctx))
// Example input: // // [EventSource(Guid = "49592C0F-5A05-516D-AA4B-A64E02026C89", Name = "System.Runtime")] // [EventSourceAutoGenerate] // internal sealed partial class RuntimeEventSource : EventSource // // Example generated output: // // using System; // // namespace System.Diagnostics.Tracing // { // partial class RuntimeEventSource // { // private RuntimeEventSource() : base(new Guid(0x49592c0f,0x5a05,0x516d,0xaa,0x4b,0xa6,0x4e,0x02,0x02,0x6c,0x89), "System.Runtime") { } // // private protected override ReadOnlySpan<byte> ProviderMetadata => new byte[] { 0x11, 0x0, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x0, }; // } // } public void Initialize(IncrementalGeneratorInitializationContext context) { IncrementalValuesProvider <EventSourceClass> eventSourceClasses = context.SyntaxProvider .CreateSyntaxProvider(IsSyntaxTargetForGeneration, GetSemanticTargetForGeneration) .Where(x => x is not null); context.RegisterSourceOutput(eventSourceClasses, EmitSourceFile); }
public void Initialize(IncrementalGeneratorInitializationContext context) { var razorSourceGeneratorOptionsWithDiagnostics = context.AnalyzerConfigOptionsProvider .Combine(context.ParseOptionsProvider) .Select(ComputeRazorSourceGeneratorOptions); var razorSourceGeneratorOptions = razorSourceGeneratorOptionsWithDiagnostics.ReportDiagnostics(context); var sourceItemsWithDiagnostics = context.AdditionalTextsProvider .Where(static (file) => file.Path.EndsWith(".razor") || file.Path.EndsWith(".cshtml"))
public void Initialize(IncrementalGeneratorInitializationContext context) { context.RegisterPostInitializationOutput(GenerateInitialCode); var options = context.AnalyzerConfigOptionsProvider .Select(Options.Select) .WithComparer(EqualityComparer <Options> .Default); var file = context.CompilationProvider .Select(static (compilation, token) =>
public void Initialize(IncrementalGeneratorInitializationContext context) { // To avoid invalidating the generator's output when anything from the compilation // changes, we will extract from it the only thing we care about: whether unsafe // code is allowed. IncrementalValueProvider <bool> allowUnsafeProvider = context.CompilationProvider .Select((x, _) => x.Options is CSharpCompilationOptions { AllowUnsafe: true });
public void Initialize(IncrementalGeneratorInitializationContext context) { var declarations = context .SyntaxProvider .CreateSyntaxProvider(SyntaxProvider.Filter, SyntaxProvider.Transform) .Where(x => x is not null); var compilationsAndDeclarations = context.CompilationProvider.Combine(declarations.Collect()); context.RegisterSourceOutput(compilationsAndDeclarations, SourceOutput.Write); }
public void Initialize(IncrementalGeneratorInitializationContext context) { // Produces one entry per generated regex. This may be: // - Diagnostic in the case of a failure that should end the compilation // - (RegexMethod regexMethod, string runnerFactoryImplementation, Dictionary<string, string[]> requiredHelpers) in the case of valid regex // - (RegexMethod regexMethod, string reason, Diagnostic diagnostic) in the case of a limited-support regex IncrementalValueProvider <ImmutableArray <object> > codeOrDiagnostics = context.SyntaxProvider // Find all MethodDeclarationSyntax nodes attributed with RegexGenerator and gather the required information. .CreateSyntaxProvider(IsSyntaxTargetForGeneration, GetSemanticTargetForGeneration) .Where(static m => m is not null)
public void Initialize(IncrementalGeneratorInitializationContext context) { var results = context .AdditionalTextsProvider .Where(x => x.Path.EndsWith(MarkupFileExt, StringComparison.OrdinalIgnoreCase)) .Select((x, ct) => { ct.ThrowIfCancellationRequested(); return(new MarkupFile(x.Path, MarkupFile.ComputeFileHash(x.Path))); }) .WithComparer(MarkupFileEqualityComparer.Default) .Combine(context.CompilationProvider) .Select(static (x, ct) =>
public void Initialize(IncrementalGeneratorInitializationContext context) { var invocations = context.SyntaxProvider.CreateSyntaxProvider ( predicate: static (s, _) => IsSyntaxTargetForGeneration(s), transform: static (ctx, _) => (InvocationExpressionSyntax)ctx.Node ).Where(static m => m is not null); var compilationAndInvocations = context.CompilationProvider.Combine(invocations.Collect()); context.RegisterSourceOutput ( compilationAndInvocations,
public void Initialize(IncrementalGeneratorInitializationContext context) { IncrementalValuesProvider <ClassDeclarationSyntax> classDeclarations = context.SyntaxProvider .ForAttributeWithMetadataName( context, Parser.JsonSerializableAttributeFullName, (node, _) => node is ClassDeclarationSyntax, (context, _) => (ClassDeclarationSyntax)context.TargetNode); IncrementalValueProvider <(Compilation, ImmutableArray <ClassDeclarationSyntax>)> compilationAndClasses = context.CompilationProvider.Combine(classDeclarations.Collect()); context.RegisterSourceOutput(compilationAndClasses, (spc, source) => Execute(source.Item1, source.Item2, spc)); }
public void Initialize(IncrementalGeneratorInitializationContext context) { var _attributes = "GenerateHandler,GenerateRequestMethods,GenerateHandlerMethods"; var syntaxProvider = context.SyntaxProvider.CreateSyntaxProvider( (syntaxNode, _) => syntaxNode is TypeDeclarationSyntax tds and(ClassDeclarationSyntax or RecordDeclarationSyntax or InterfaceDeclarationSyntax) && tds.AttributeLists.ContainsAttribute(_attributes), (syntaxContext, _) => syntaxContext ) .Combine(context.CompilationProvider) .Select( (tuple, _) => { var(syntaxContext, compilaiton) = tuple; var additionalUsings = new HashSet <string> { "System", "System.Collections.Generic", "System.Threading", "System.Threading.Tasks", "MediatR", "Microsoft.Extensions.DependencyInjection" }; GeneratorData?actionItem = null; Diagnostic?diagnostic = null; try { actionItem = GeneratorData.Create( compilaiton, (TypeDeclarationSyntax)syntaxContext.Node, syntaxContext.SemanticModel, additionalUsings ); } catch (Exception e) { diagnostic = Diagnostic.Create( GeneratorDiagnostics.Exception, syntaxContext.Node.GetLocation(), e.Message, e.StackTrace ?? string.Empty ); Debug.WriteLine(e); Debug.WriteLine(e.StackTrace); } return(actionItem, diagnostic, additionalUsings); } ); context.RegisterSourceOutput(syntaxProvider, GenerateHandlerMethods); context.RegisterSourceOutput( syntaxProvider.Where(z => z.actionItem is { }).SelectMany((z, _) => z.actionItem !.AssemblyJsonRpcHandlersAttributeArguments).Collect(),
// Example input: // // [EventSource(Guid = "49592C0F-5A05-516D-AA4B-A64E02026C89", Name = "System.Runtime")] // [EventSourceAutoGenerate] // internal sealed partial class RuntimeEventSource : EventSource // // Example generated output: // // using System; // // namespace System.Diagnostics.Tracing // { // partial class RuntimeEventSource // { // private RuntimeEventSource() : base(new Guid(0x49592c0f,0x5a05,0x516d,0xaa,0x4b,0xa6,0x4e,0x02,0x02,0x6c,0x89), "System.Runtime") { } // // private protected override ReadOnlySpan<byte> ProviderMetadata => new byte[] { 0x11, 0x0, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x0, }; // } // } public void Initialize(IncrementalGeneratorInitializationContext context) { const string EventSourceAutoGenerateAttribute = "System.Diagnostics.Tracing.EventSourceAutoGenerateAttribute"; IncrementalValuesProvider <EventSourceClass> eventSourceClasses = context.SyntaxProvider.ForAttributeWithMetadataName( context, EventSourceAutoGenerateAttribute, (node, _) => node is ClassDeclarationSyntax, GetSemanticTargetForGeneration) .Where(x => x is not null); context.RegisterSourceOutput(eventSourceClasses, EmitSourceFile); }
public void Initialize(IncrementalGeneratorInitializationContext initContext) { //#if DEBUG // if (!System.Diagnostics.Debugger.IsAttached) // System.Diagnostics.Debugger.Launch(); //#endif var projectItemProvider = initContext.AdditionalTextsProvider .Combine(initContext.AnalyzerConfigOptionsProvider) .Select(ComputeProjectItem); var xmlnsDefinitionsProvider = initContext.CompilationProvider .Select(GetXmlnsDefinitionAttributes); var sourceProvider = projectItemProvider .Combine(xmlnsDefinitionsProvider) .Combine(initContext.CompilationProvider) .Select(static (t, _) => (t.Left.Left, t.Left.Right, t.Right));
public void Initialize(IncrementalGeneratorInitializationContext context) { // determine if we should suppress this run and set all the inputs to cached if so var isGeneratorSuppressed = context.AnalyzerConfigOptionsProvider.Select(GetSuppressionStatus); var analyzerConfigOptions = context.AnalyzerConfigOptionsProvider.AsCachedIfSuppressed(isGeneratorSuppressed); var additionalTexts = context.AdditionalTextsProvider.AsCachedIfSuppressed(isGeneratorSuppressed); var parseOptions = context.ParseOptionsProvider.AsCachedIfSuppressed(isGeneratorSuppressed); var compilation = context.CompilationProvider.AsCachedIfSuppressed(isGeneratorSuppressed); var razorSourceGeneratorOptions = analyzerConfigOptions .Combine(parseOptions) .Select(ComputeRazorSourceGeneratorOptions) .ReportDiagnostics(context); var sourceItems = additionalTexts .Where(static (file) => file.Path.EndsWith(".razor", StringComparison.OrdinalIgnoreCase) || file.Path.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase))
public void Initialize(IncrementalGeneratorInitializationContext context) { var candidatesProvider = context.SyntaxProvider.CreateSyntaxProvider( (syntaxNode, _) => SourceGeneratorSyntaxReceiver.IsCandidate(syntaxNode), (syntaxContext, _) => (ClassDeclarationSyntax)syntaxContext.Node); var assemblyResolverProvider = context.AnalyzerConfigOptionsProvider.Select((provider, _) => new AssemblyResolver(provider.GlobalOptions)); var compilationProvider = context.CompilationProvider.Select((compilation, _) => compilation); var source = candidatesProvider .Collect() .Combine(assemblyResolverProvider) .Combine(compilationProvider) .Select((i, _) => (i.Left.Left, i.Left.Right, i.Right)); context.RegisterSourceOutput(source, Execute); }
public void Initialize(IncrementalGeneratorInitializationContext context) { //#if DEBUG // if (!Debugger.IsAttached) // { // Debugger.Launch(); // } //#endif // collect remote services var interfaceTypes = context.SyntaxProvider .CreateSyntaxProvider(CollectRegisterRemoteMethods, GetProxyInterface) .Where(type => type is not null) .Collect(); // collect target assembly name var assemblyName = context.CompilationProvider.Select(static (cp, _) => cp.AssemblyName);
public void Initialize(IncrementalGeneratorInitializationContext context) { var attributes = context.CompilationProvider .Select( (compilation, _) => { var registrationOptionsInterfaceSymbol = compilation.GetTypeByMetadataName("OmniSharp.Extensions.LanguageServer.Protocol.IRegistrationOptions") !; var textDocumentRegistrationOptionsInterfaceSymbol = compilation.GetTypeByMetadataName( "OmniSharp.Extensions.LanguageServer.Protocol.Models.ITextDocumentRegistrationOptions" ) !; var workDoneProgressOptionsInterfaceSymbol = compilation.GetTypeByMetadataName( "OmniSharp.Extensions.LanguageServer.Protocol.Models.IWorkDoneProgressOptions" ) !; var staticRegistrationOptionsInterfaceSymbol = compilation.GetTypeByMetadataName( "OmniSharp.Extensions.LanguageServer.Protocol.Models.IStaticRegistrationOptions" ) !; return(new AttributeData( registrationOptionsInterfaceSymbol, textDocumentRegistrationOptionsInterfaceSymbol, workDoneProgressOptionsInterfaceSymbol, staticRegistrationOptionsInterfaceSymbol )); } ); var syntaxProvider = context.SyntaxProvider.CreateSyntaxProvider( (syntaxNode, _) => syntaxNode is TypeDeclarationSyntax tds and(ClassDeclarationSyntax or RecordDeclarationSyntax) && tds.AttributeLists .SelectMany(z => z.Attributes) .Any(z => z.Name.ToFullString().Contains("GenerateRegistrationOptions")), (syntaxContext, _) => syntaxContext ) .Combine(context.CompilationProvider) .Select( (tuple, _) => { var(syntaxContext, compilation) = tuple; var typeSymbol = syntaxContext.SemanticModel.GetDeclaredSymbol((TypeDeclarationSyntax) syntaxContext.Node); if (typeSymbol is not { }) { return(default !);
/// <summary> /// Registers a post-initialization step for the source generator context to add some embedded resources to the /// compilation. /// </summary> /// <param name="context">The source generator context.</param> /// <param name="prefix">The prefix of the embedded sources to add.</param> public static void RegisterEmbeddedSourceCodeInjection( this IncrementalGeneratorInitializationContext context, string prefix) { var assembly = Assembly.GetExecutingAssembly(); var sourcesToInject = assembly .GetManifestResourceNames() .Where(m => m.StartsWith(prefix)); context.RegisterPostInitializationOutput(ctx => { foreach (var source in sourcesToInject) { ctx.AddSource( source, SourceText.From(assembly.ReadManifestResourceText(source), Encoding.UTF8)); } }); }
public void Initialize(IncrementalGeneratorInitializationContext context) { context.RegisterPostInitializationOutput(ctx => ctx.AddSource( "Attributes.g.cs", Templates.UnionTypeTemplates.StaticCode)); var unionTypeClasses = context.SyntaxProvider .CreateSyntaxProvider( predicate: static (s, _) => s.IsTypeDeclarationWithAttributes(), transform: static (ctx, _) => GeneratorHelper.GetSemanticTargetForGeneration(ctx, UnionTypeAttribute) ) .Where(static target => target != null) .Select(static (target, _) => target !); var compilationAndClasses = context.CompilationProvider.Combine(unionTypeClasses.Collect()); context.RegisterSourceOutput( compilationAndClasses,
public void Initialize(IncrementalGeneratorInitializationContext context) { var syntaxProvider = context.SyntaxProvider.CreateSyntaxProvider( predicate: (syntaxNode, _) => IsSupportedSyntaxNode(syntaxNode), transform: (generatorSyntaxContext, _) => generatorSyntaxContext.Node); var globalConfig = ProjectFileReader.ReadApplicationConfig(context.AnalyzerConfigOptionsProvider); var inputs = context.CompilationProvider .Combine(syntaxProvider.Collect()) .Combine(globalConfig) .Select((data, cancellationToken) => (Compilation: data.Left.Left, Nodes: data.Left.Right, ApplicationConfig: data.Right.ApplicationConfig, ApplicationConfigDiagnostics: data.Right.Diagnostic)); context.RegisterSourceOutput( inputs, (context, source) => Execute(context, source.Nodes, source.Compilation.Options.OutputKind, source.ApplicationConfig, source.ApplicationConfigDiagnostics)); }
public void Initialize(IncrementalGeneratorInitializationContext context) { var attributes = context.CompilationProvider .Select( (compilation, _) => new AttributeData( compilation.GetTypeByMetadataName( "OmniSharp.Extensions.LanguageServer.Protocol.Generation.GenerateTypedDataAttribute" ) !, compilation.GetTypeByMetadataName( "OmniSharp.Extensions.LanguageServer.Protocol.Generation.GenerateContainerAttribute" ) ! ) ); var createContainersSyntaxProvider = context.SyntaxProvider.CreateSyntaxProvider( (syntaxNode, _) => syntaxNode switch { StructDeclarationSyntax structDeclarationSyntax when structDeclarationSyntax.AttributeLists.ContainsAttribute("GenerateContainer") => true, TypeDeclarationSyntax typeDeclarationSyntax and(ClassDeclarationSyntax or RecordDeclarationSyntax) when typeDeclarationSyntax .AttributeLists.ContainsAttribute("GenerateContainer") => true, _ => false }, (syntaxContext, _) => syntaxContext
public void Initialize(IncrementalGeneratorInitializationContext context) { var syntaxProvider = context.SyntaxProvider.CreateSyntaxProvider( (syntaxNode, _) => { if (syntaxNode.Parent is TypeDeclarationSyntax) { return(false); } if (syntaxNode is TypeDeclarationSyntax { Arity: 0, BaseList: { } bl } typeDeclarationSyntax and(ClassDeclarationSyntax or RecordDeclarationSyntax) && !typeDeclarationSyntax.Modifiers.Any(SyntaxKind.AbstractKeyword) && typeDeclarationSyntax.AttributeLists.ContainsAttribute("CapabilityKey") && bl.Types.Any( z => z.Type switch { SimpleNameSyntax { Identifier: { Text: "ICapability" or "DynamicCapability" or "IDynamicCapability" or "LinkSupportCapability" }, Arity: 0 } => true,