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,
