protected static GeneratorResult RunGenerator(
Compilation compilation,
ISourceGenerator generator,
IEnumerable <AdditionalText> additionalTexts = null,
CSharpParseOptions parseOptions = null,
AnalyzerConfigOptionsProvider optionsProvider = null)
=> RunGenerator(compilation, new[] { generator }, additionalTexts, parseOptions, optionsProvider);
public static AggregateCategorizedAnalyzerConfigOptions Create(AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, Compilation compilation, CompilationCategorizedAnalyzerConfigOptions additionalFileBasedOptions)
{
analyzerConfigOptionsProvider = analyzerConfigOptionsProvider ?? throw new ArgumentNullException(nameof(analyzerConfigOptionsProvider));
additionalFileBasedOptions = additionalFileBasedOptions ?? throw new ArgumentNullException(nameof(additionalFileBasedOptions));
if (analyzerConfigOptionsProvider.IsEmpty() && additionalFileBasedOptions.IsEmpty)
{
return(Empty);
}
Lazy <SyntaxTreeCategorizedAnalyzerConfigOptions>?globalOptions;
#if CODEANALYSIS_V3_7_OR_BETTER
globalOptions = new Lazy <SyntaxTreeCategorizedAnalyzerConfigOptions>(() => SyntaxTreeCategorizedAnalyzerConfigOptions.Create(analyzerConfigOptionsProvider.GlobalOptions));
#else
globalOptions = null;
#endif
var perTreeOptionsBuilder = PooledDictionary <SyntaxTree, Lazy <SyntaxTreeCategorizedAnalyzerConfigOptions> > .GetInstance();
foreach (var tree in compilation.SyntaxTrees)
{
perTreeOptionsBuilder.Add(tree, new Lazy <SyntaxTreeCategorizedAnalyzerConfigOptions>(() => Create(tree, analyzerConfigOptionsProvider)));
}
return(new AggregateCategorizedAnalyzerConfigOptions(globalOptions, perTreeOptionsBuilder.ToImmutableDictionaryAndFree(), additionalFileBasedOptions));
protected override AnalyzerOptions CreateAnalyzerOptions(
ImmutableArray <AdditionalText> additionalTextFiles,
AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider)
{
AnalyzerOptions = base.CreateAnalyzerOptions(additionalTextFiles, analyzerConfigOptionsProvider);
return(AnalyzerOptions);
}
internal GeneratorDriverState(ParseOptions parseOptions,
AnalyzerConfigOptionsProvider optionsProvider,
ImmutableArray <ISourceGenerator> sourceGenerators,
ImmutableArray <IIncrementalGenerator> incrementalGenerators,
ImmutableArray <AdditionalText> additionalTexts,
ImmutableArray <GeneratorState> generatorStates,
DriverStateTable stateTable,
SyntaxStore syntaxStore,
IncrementalGeneratorOutputKind disabledOutputs,
TimeSpan runtime,
bool trackIncrementalGeneratorSteps)
{
Generators = sourceGenerators;
IncrementalGenerators = incrementalGenerators;
GeneratorStates = generatorStates;
AdditionalTexts = additionalTexts;
ParseOptions = parseOptions;
OptionsProvider = optionsProvider;
StateTable = stateTable;
SyntaxStore = syntaxStore;
DisabledOutputs = disabledOutputs;
RunTime = runtime;
TrackIncrementalSteps = trackIncrementalGeneratorSteps;
Debug.Assert(Generators.Length == GeneratorStates.Length);
Debug.Assert(IncrementalGenerators.Length == GeneratorStates.Length);
}
public GenerationContext(SyntaxNode node, SemanticModel semanticModel, ImmutableArray <AdditionalText> additionalFiles, AnalyzerConfigOptionsProvider analyzerConfigOptions, CancellationToken cancellationToken)
{
Node = node;
SemanticModel = semanticModel;
AdditionalFiles = additionalFiles;
AnalyzerConfigOptions = analyzerConfigOptions;
CancellationToken = cancellationToken;
}
/// <summary>
/// Creates a new instance of <see cref="CSharpGeneratorDriver"/>
/// </summary>
/// <param name="parseOptions">The <see cref="CSharpParseOptions"/> that should be used when parsing generated files.</param>
/// <param name="generators">The generators that will run as part of this driver.</param>
/// <param name="optionsProvider">An <see cref="AnalyzerConfigOptionsProvider"/> that can be used to retrieve analyzer config values by the generators in this driver.</param>
/// <param name="additionalTexts">A list of <see cref="AdditionalText"/>s available to generators in this driver.</param>
internal CSharpGeneratorDriver(
CSharpParseOptions parseOptions,
ImmutableArray <ISourceGenerator> generators,
AnalyzerConfigOptionsProvider optionsProvider,
ImmutableArray <AdditionalText> additionalTexts
) : base(parseOptions, generators, optionsProvider, additionalTexts)
{
}
public static bool IsEmpty(this AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider)
{
// Reflection based optimization for empty analyzer config options.
// Ideally 'AnalyzerConfigOptionsProvider.IsEmpty' would be exposed in the API.
const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
return(analyzerConfigOptionsProvider.GetType().GetField("_treeDict", flags)?.GetValue(analyzerConfigOptionsProvider) is ImmutableDictionary <object, AnalyzerConfigOptions> perTreeOptionsMap &&
perTreeOptionsMap.IsEmpty);
}
internal SourceGeneratorContext(Compilation compilation, ImmutableArray <AdditionalText> additionalTexts, AnalyzerConfigOptionsProvider optionsProvider, ISyntaxReceiver?syntaxReceiver, CancellationToken cancellationToken = default)
{
Compilation = compilation;
AdditionalFiles = additionalTexts;
AnalyzerConfigOptions = optionsProvider;
SyntaxReceiver = syntaxReceiver;
CancellationToken = cancellationToken;
_additionalSources = new AdditionalSourcesCollection();
_diagnostics = new DiagnosticBag();
}
public ConfigurationValues(AnalyzerConfigOptionsProvider optionsProvider, SyntaxTree tree)
{
var options = optionsProvider.GetOptions(tree);
this.IndentStyle = options.TryGetValue(ConfigurationValues.IndentStyleKey, out var indentStyle) ?
(Enum.TryParse <IndentStyle>(indentStyle, out var indentStyleValue) ? indentStyleValue : ConfigurationValues.IndentStyleDefaultValue) :
ConfigurationValues.IndentStyleDefaultValue;
this.IndentSize = options.TryGetValue(ConfigurationValues.IndentSizeKey, out var indentSize) ?
(uint.TryParse(indentSize, out var indentSizeValue) ? indentSizeValue : ConfigurationValues.IndentSizeDefaultValue) :
ConfigurationValues.IndentSizeDefaultValue;
}
public SymbolAnalysisContextSource(ISymbol symbol,
Compilation compilation,
ImmutableArray <AdditionalText> additionalFiles,
AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider,
CancellationToken cancellationToken)
{
Symbol = symbol;
Compilation = compilation;
AdditionalFiles = additionalFiles;
AnalyzerConfigOptionsProvider = analyzerConfigOptionsProvider;
CancellationToken = cancellationToken;
}
public SymbolAnalysisContext(TSymbol symbol,
Compilation compilation,
ImmutableArray <AdditionalText> additionalFiles,
AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider,
CancellationToken cancellationToken)
{
Symbol = symbol;
Compilation = compilation ?? throw new ArgumentNullException(nameof(compilation));
AdditionalFiles = additionalFiles;
AnalyzerConfigOptionsProvider = analyzerConfigOptionsProvider ?? throw new ArgumentNullException(nameof(analyzerConfigOptionsProvider));
CancellationToken = cancellationToken;
}
internal GeneratorExecutionContext(Compilation compilation, ParseOptions parseOptions, ImmutableArray <AdditionalText> additionalTexts, AnalyzerConfigOptionsProvider optionsProvider, ISyntaxContextReceiver?syntaxReceiver, AdditionalSourcesCollection additionalSources, CancellationToken cancellationToken = default)
{
Compilation = compilation;
ParseOptions = parseOptions;
AdditionalFiles = additionalTexts;
AnalyzerConfigOptions = optionsProvider;
SyntaxReceiver = (syntaxReceiver as SyntaxContextReceiverAdaptor)?.Receiver;
SyntaxContextReceiver = (syntaxReceiver is SyntaxContextReceiverAdaptor) ? null : syntaxReceiver;
CancellationToken = cancellationToken;
_additionalSources = additionalSources;
_diagnostics = new DiagnosticBag();
}
public static void CheckDebugger(this AnalyzerConfigOptionsProvider provider, string generatorName = nameof(SmallSharp))
{
if (Process.GetCurrentProcess().ProcessName == "devenv")
{
return;
}
if (provider.IsEnabled("DebugSourceGenerators") ||
provider.IsEnabled("Debug" + generatorName))
{
Debugger.Launch();
}
}
public SyntaxNodeAnalysisContext(TSyntax node,
ISymbol?containingSymbol,
SemanticModel semanticModel,
ImmutableArray <AdditionalText> additionalTexts,
AnalyzerConfigOptionsProvider analyzerConfigOptions,
CancellationToken cancellationToken)
{
Node = node;
ContainingSymbol = containingSymbol;
SemanticModel = semanticModel;
AdditionalTexts = additionalTexts;
AnalyzerConfigOptions = analyzerConfigOptions;
CancellationToken = cancellationToken;
}
public static void CheckDebugger(this AnalyzerConfigOptionsProvider analyzerOptions, string debugableName)
{
if (analyzerOptions.GlobalOptions.TryGetValue("build_property.DebugSourceGenerators", out var debugValue) &&
bool.TryParse(debugValue, out var shouldDebug) &&
shouldDebug)
{
Debugger.Launch();
}
else if (analyzerOptions.GlobalOptions.TryGetValue("build_property.Debug" + debugableName, out debugValue) &&
bool.TryParse(debugValue, out shouldDebug) &&
shouldDebug)
{
Debugger.Launch();
}
}
public SyntaxNodeAnalysisContextSource(SyntaxNode node,
SemanticModel semanticModel,
Compilation compilation,
ImmutableArray <AdditionalText> additionalTexts,
AnalyzerConfigOptionsProvider analyzerConfigOptions,
CancellationToken cancellationToken)
{
Node = node;
ContainingSymbol = semanticModel.GetDeclaredSymbol(node, cancellationToken) ?? semanticModel.GetSymbolInfo(node, cancellationToken).Symbol;
SemanticModel = semanticModel;
Compilation = compilation;
AdditionalTexts = additionalTexts;
AnalyzerConfigOptions = analyzerConfigOptions;
CancellationToken = cancellationToken;
}
protected static GeneratorResult RunGenerator(
Compilation compilation,
IEnumerable <ISourceGenerator> generators,
IEnumerable <AdditionalText> additionalTexts = null,
CSharpParseOptions parseOptions = null,
AnalyzerConfigOptionsProvider optionsProvider = null)
{
var driver = CSharpGeneratorDriver.Create(generators, additionalTexts, parseOptions, optionsProvider);
driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var diagnostics);
return(new GeneratorResult((CSharpCompilation)outputCompilation, diagnostics,
outputCompilation.SyntaxTrees.Except(compilation.SyntaxTrees, new SyntaxComparer())
.Cast <CSharpSyntaxTree>().ToImmutableArray()));
}
internal GeneratorDriver(
ParseOptions parseOptions,
ImmutableArray <ISourceGenerator> generators,
AnalyzerConfigOptionsProvider optionsProvider,
ImmutableArray <AdditionalText> additionalTexts
)
{
_state = new GeneratorDriverState(
parseOptions,
optionsProvider,
generators,
additionalTexts,
ImmutableArray.Create(new GeneratorState[generators.Length]),
ImmutableArray <PendingEdit> .Empty,
editsFailed: true
);
}
internal GeneratorDriverState(ParseOptions parseOptions,
AnalyzerConfigOptionsProvider optionsProvider,
ImmutableArray <ISourceGenerator> generators,
ImmutableArray <AdditionalText> additionalTexts,
ImmutableArray <GeneratorState> generatorStates,
ImmutableArray <PendingEdit> edits,
bool editsFailed)
{
Generators = generators;
GeneratorStates = generatorStates;
AdditionalTexts = additionalTexts;
Edits = edits;
ParseOptions = parseOptions;
OptionsProvider = optionsProvider;
EditsFailed = editsFailed;
Debug.Assert(Generators.Length == GeneratorStates.Length);
}
internal GeneratorDriverState(ParseOptions parseOptions,
AnalyzerConfigOptionsProvider optionsProvider,
ImmutableArray <ISourceGenerator> sourceGenerators,
ImmutableArray <IIncrementalGenerator> incrementalGenerators,
ImmutableArray <AdditionalText> additionalTexts,
ImmutableArray <GeneratorState> generatorStates,
DriverStateTable stateTable,
bool enableIncremental)
{
Generators = sourceGenerators;
IncrementalGenerators = incrementalGenerators;
GeneratorStates = generatorStates;
AdditionalTexts = additionalTexts;
ParseOptions = parseOptions;
OptionsProvider = optionsProvider;
StateTable = stateTable;
EnableIncremental = enableIncremental;
Debug.Assert(Generators.Length == GeneratorStates.Length);
Debug.Assert(IncrementalGenerators.Length == GeneratorStates.Length);
}
private static ImmutableArray <(ImmutableArray <Diagnostic> diagnostics, string?name, SourceText?text)> GenerateMappings(
MapReceiver receiver, Compilation compilation, AnalyzerConfigOptionsProvider optionsProvider)
{
var results = ImmutableArray.CreateBuilder <(ImmutableArray <Diagnostic> diagnostics, string?name, SourceText?text)>();
var information = new MappingInformation(receiver, compilation);
foreach (var mapPair in information.Maps)
{
if (!mapPair.Value.diagnostics.Any(_ => _.Severity == DiagnosticSeverity.Error))
{
var text = new MappingBuilder(mapPair.Key.source, mapPair.Key.destination, mapPair.Value.maps,
new ConfigurationValues(optionsProvider, mapPair.Value.node.SyntaxTree)).Text;
results.Add((mapPair.Value.diagnostics, $"{mapPair.Key.source.Name}_To_{mapPair.Key.destination.Name}_Map.g.cs", text));
}
else
{
results.Add((mapPair.Value.diagnostics, null, null));
}
}
return(results.ToImmutable());
}
private protected override Compilation RunGenerators(
Compilation input,
ParseOptions parseOptions,
ImmutableArray <ISourceGenerator> generators,
AnalyzerConfigOptionsProvider analyzerConfigProvider,
ImmutableArray <AdditionalText> additionalTexts,
DiagnosticBag diagnostics
)
{
var driver = CSharpGeneratorDriver.Create(
generators,
additionalTexts,
(CSharpParseOptions)parseOptions,
analyzerConfigProvider
);
driver.RunGeneratorsAndUpdateCompilation(
input,
out var compilationOut,
out var generatorDiagnostics
);
diagnostics.AddRange(generatorDiagnostics);
return(compilationOut);
}
public OptionsProvider(AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, List <(string, string)> globalOptions)
internal GeneratorDriver(ParseOptions parseOptions, ImmutableArray <ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray <AdditionalText> additionalTexts, GeneratorDriverOptions driverOptions)
{
(var filteredGenerators, var incrementalGenerators) = GetIncrementalGenerators(generators, SourceExtension);
_state = new GeneratorDriverState(parseOptions, optionsProvider, filteredGenerators, incrementalGenerators, additionalTexts, ImmutableArray.Create(new GeneratorState[filteredGenerators.Length]), DriverStateTable.Empty, SyntaxStore.Empty, driverOptions.DisabledOutputs, runtime: TimeSpan.Zero, driverOptions.TrackIncrementalGeneratorSteps);
}
static SyntaxTreeCategorizedAnalyzerConfigOptions Create(SyntaxTree tree, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider)
{
var options = analyzerConfigOptionsProvider.GetOptions(tree);
return(SyntaxTreeCategorizedAnalyzerConfigOptions.Create(options));
}
GeneratorDriver?ICompilationFactoryService.CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray <ISourceGenerator> generators, AnalyzerConfigOptionsProvider optionsProvider, ImmutableArray <AdditionalText> additionalTexts)
{
return(CSharpGeneratorDriver.Create(generators, additionalTexts, (CSharpParseOptions)parseOptions, optionsProvider));
}
/// <summary>
/// Gets a flag that determines if the source generator should no-op.
/// <para>
/// This flag exists to support scenarios in VS where design-time and EnC builds need
/// to run without invoking the source generator to avoid duplicate types being produced.
/// The property is set by the SDK via an editor config.
/// </para>
/// </summary>
private static bool GetSuppressionStatus(AnalyzerConfigOptionsProvider optionsProvider, CancellationToken _)
{
return(optionsProvider.GlobalOptions.TryGetValue("build_property.SuppressRazorSourceGenerator", out var suppressRazorSourceGenerator) &&
suppressRazorSourceGenerator == "true");
}
private protected override Compilation RunGenerators(Compilation input, ParseOptions parseOptions, ImmutableArray <ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigProvider, ImmutableArray <AdditionalText> additionalTexts, DiagnosticBag diagnostics)
{
// https://github.com/dotnet/roslyn/issues/42565: for now we gate behind langver == preview. We'll remove this before final shipping, as the feature is langver agnostic
if (((CSharpParseOptions)parseOptions).LanguageVersion != LanguageVersion.Preview)
{
return(input);
}
var driver = CSharpGeneratorDriver.Create(generators, additionalTexts, (CSharpParseOptions)parseOptions, analyzerConfigProvider);
driver.RunGeneratorsAndUpdateCompilation(input, out var compilationOut, out var generatorDiagnostics);
diagnostics.AddRange(generatorDiagnostics);
return(compilationOut);
}
static bool IsGenerationDisabledByOptions(AnalyzerConfigOptionsProvider optionsProvider)
=> optionsProvider.GlobalOptions.TryGetValue(GlobalOptionsNames.Enable, out var value) &&
value.Equals("false", StringComparison.InvariantCultureIgnoreCase);
/// <summary>
/// Run the supplied generators on the compilation.
/// </summary>
/// <param name="comp">Compilation target</param>
/// <param name="diagnostics">Resulting diagnostics</param>
/// <param name="generators">Source generator instances</param>
/// <returns>The resulting compilation</returns>
public static Compilation RunGenerators(Compilation comp, AnalyzerConfigOptionsProvider options, out ImmutableArray <Diagnostic> diagnostics, params IIncrementalGenerator[] generators)
{
CreateDriver(comp, options, generators).RunGeneratorsAndUpdateCompilation(comp, out var d, out diagnostics);
return(d);
}
