public override void Initialize(AnalysisContext analysisContext) { analysisContext.EnableConcurrentExecution(); analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterCompilationStartAction( context => { INamedTypeSymbol?disposableType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemIDisposable); if (disposableType == null) { return; } if (!(disposableType.GetMembers(DisposeMethodName).FirstOrDefault() is IMethodSymbol disposeInterfaceMethod)) { return; } INamedTypeSymbol?garbageCollectorType = context.Compilation.GetOrCreateTypeByMetadataName(GarbageCollectorTypeName); if (garbageCollectorType == null) { return; } if (!(garbageCollectorType.GetMembers(SuppressFinalizeMethodName).FirstOrDefault() is IMethodSymbol suppressFinalizeMethod)) { return; } var analyzer = new PerCompilationAnalyzer(disposableType, disposeInterfaceMethod, suppressFinalizeMethod); analyzer.Initialize(context); }); }
public override void Initialize(AnalysisContext analysisContext) { // this is stateless analyzer, can run concurrently analysisContext.EnableConcurrentExecution(); // this has no meaning on running on generated code which user can't control analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterCompilationStartAction(c => { INamedTypeSymbol @string = WellKnownTypes.String(c.Compilation); INamedTypeSymbol uri = WellKnownTypes.Uri(c.Compilation); if (@string == null || uri == null) { // we don't have required types return; } var analyzer = new PerCompilationAnalyzer(c.Compilation, @string, uri, GetInvocationExpression); // REVIEW: I need to do this thing because OperationAnalysisContext doesn't give me OwningSymbol c.RegisterOperationBlockStartAction(sc => { sc.RegisterOperationAction(oc => analyzer.Analyze(oc, sc.OwningSymbol), OperationKind.InvocationExpression); }); }); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.RegisterCompilationStartAction( context => { INamedTypeSymbol disposableType = WellKnownTypes.IDisposable(context.Compilation); if (disposableType == null) { return; } var disposeInterfaceMethod = disposableType.GetMembers(DisposeMethodName).Single() as IMethodSymbol; if (disposeInterfaceMethod == null) { return; } INamedTypeSymbol garbageCollectorType = context.Compilation.GetTypeByMetadataName(GarbageCollectorTypeName); if (garbageCollectorType == null) { return; } var suppressFinalizeMethod = garbageCollectorType.GetMembers(SuppressFinalizeMethodName).Single() as IMethodSymbol; if (suppressFinalizeMethod == null) { return; } var analyzer = new PerCompilationAnalyzer(context.Compilation, disposableType, disposeInterfaceMethod, suppressFinalizeMethod); analyzer.Initialize(context); }); }
public override void Initialize(AnalysisContext analysisContext) { // this is stateless analyzer, can run concurrently analysisContext.EnableConcurrentExecution(); // this has no meaning on running on generated code which user can't control analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterCompilationStartAction(c => { INamedTypeSymbol @string = WellKnownTypes.String(c.Compilation); INamedTypeSymbol uri = WellKnownTypes.Uri(c.Compilation); if (@string == null || uri == null) { // we don't have required types return; } var analyzer = new PerCompilationAnalyzer(c.Compilation, @string, uri, GetInvocationExpression); // REVIEW: I need to do this thing because OperationAnalysisContext doesn't give me OwningSymbol c.RegisterOperationBlockStartAction(sc => { sc.RegisterOperationAction(oc => analyzer.Analyze(oc, sc.OwningSymbol), OperationKind.Invocation); }); }); }
private void PrepareForAnalysis(CompilationStartAnalysisContext context) { var perCompilationAnalyzer = new PerCompilationAnalyzer(context.Compilation); // TODO: Change this from a SyntaxNode action to an operation attribute once attribute application is represented in the // IOperation tree by Roslyn. context.RegisterSyntaxNodeAction(perCompilationAnalyzer.AnalyzeAttribute, SyntaxKind.Attribute); }
private void PrepareForAnalysis(CompilationStartAnalysisContext context) { if (context.Compilation.GetBestTypeByMetadataName(TypeNames.CustomMarshallerAttribute) is not null) { var perCompilationAnalyzer = new PerCompilationAnalyzer(context.Compilation); // TODO: Change this from a SyntaxNode action to an operation attribute once attribute application is represented in the // IOperation tree by Roslyn. context.RegisterSyntaxNodeAction(perCompilationAnalyzer.AnalyzeAttribute, SyntaxKind.Attribute); } }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterCompilationStartAction(context => { if (context.Compilation.TryGetOrCreateTypeByMetadataName( WellKnownTypeNames.SystemRuntimeCompilerServicesDisableRuntimeMarshallingAttribute, out INamedTypeSymbol? disableRuntimeMarshallingAttribute) && context.Compilation.Assembly.HasAttribute(disableRuntimeMarshallingAttribute)) { var perCompilationAnalyzer = new PerCompilationAnalyzer(context.Compilation); perCompilationAnalyzer.RegisterActions(context); } }); }
public override void Initialize(AnalysisContext context) { // this is stateless analyzer, can run concurrently context.EnableConcurrentExecution(); // this has no meaning on running on generated code which user can't control context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterCompilationStartAction(c => { var attribute = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemAttribute); if (attribute == null) { // we don't have required types return; } var analyzer = new PerCompilationAnalyzer(attribute); c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Property); }); }
public override void Initialize(AnalysisContext context) { // this is stateless analyzer, can run concurrently context.EnableConcurrentExecution(); // this has no meaning on running on generated code which user can't control context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterCompilationStartAction(c => { INamedTypeSymbol?uri = c.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemUri); if (uri == null) { // we don't have required types return; } var analyzer = new PerCompilationAnalyzer(c.Compilation, uri, GetInvocationExpression); c.RegisterOperationAction(analyzer.Analyze, OperationKind.Invocation); }); }
public override void Initialize(AnalysisContext analysisContext) { // this is stateless analyzer, can run concurrently analysisContext.EnableConcurrentExecution(); // this has no meaning on running on generated code which user can't control analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterCompilationStartAction(c => { var @string = WellKnownTypes.String(c.Compilation); var uri = WellKnownTypes.Uri(c.Compilation); if (@string == null || uri == null) { // we don't have required types return; } var analyzer = new PerCompilationAnalyzer(@string, uri); c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method); }); }
public override void Initialize(AnalysisContext analysisContext) { // this is stateless analyzer, can run concurrently analysisContext.EnableConcurrentExecution(); // this has no meaning on running on generated code which user can't control analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterCompilationStartAction(c => { var @string = WellKnownTypes.String(c.Compilation); var attribute = WellKnownTypes.Attribute(c.Compilation); if (@string == null || attribute == null) { // we don't have required types return; } var analyzer = new PerCompilationAnalyzer(@string, attribute); c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Property); }); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.EnableConcurrentExecution(); analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterCompilationStartAction( context => { INamedTypeSymbol disposableType = WellKnownTypes.IDisposable(context.Compilation); if (disposableType == null) { return; } var disposeInterfaceMethod = disposableType.GetMembers(DisposeMethodName).Single() as IMethodSymbol; if (disposeInterfaceMethod == null) { return; } INamedTypeSymbol garbageCollectorType = context.Compilation.GetTypeByMetadataName(GarbageCollectorTypeName); if (garbageCollectorType == null) { return; } var suppressFinalizeMethod = garbageCollectorType.GetMembers(SuppressFinalizeMethodName).Single() as IMethodSymbol; if (suppressFinalizeMethod == null) { return; } var analyzer = new PerCompilationAnalyzer(disposableType, disposeInterfaceMethod, suppressFinalizeMethod); analyzer.Initialize(context); }); }