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); }