Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationStartAction(System.Action)

Here are the examples of the csharp api Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterCompilationStartAction(System.Action) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

114 Examples 7

19 Source : CometaryAnalyzer.cs
with MIT License
from 71

[SuppressMessage("replacedyzerPerformance", "RS1012", Justification = "Yes, all those methods register no action. It's okay.")]
        public override void Initialize(replacedysisContext context)
        {
            // Initialize this exception here
            // When testing Cometary, I noticed that 'StartAction' often wasn't called at all,
            // and nothing indicated it (no error, or warning of the sort).
            // It hasn't happened since I fixed some other stuff (huh R# won't let me use the B u g word)
            // but I'm leaving this like this, just in case.

            // basically, we default to an error, and iff StartAction is successfully ran, we
            // remove this error. if it does run an throws, we replace this error with the exception.
            Exception encounteredException = new Exception("Could not initialize Cometary.");

            void RegisterAction(CompilationStartreplacedysisContext ctx)
            {
                replacedemblyLoading.CurrentCompilation = ctx.Compilation;
            }

            void StartAction(CompilationStartreplacedysisContext ctx)
            {
                try
                {
                    Hooks.EnsureInitialized();

                    encounteredException = null;
                }
                catch (Exception e)
                {
                    encounteredException = e;
                }
            }

            void EndAction(CompilationreplacedysisContext ctx)
            {
                ctx.ReportDiagnostic(encounteredException != null
                    ? Diagnostic.Create(HookError, Location.None, encounteredException.ToString())
                    : Diagnostic.Create(HookSuccess, Location.None));
            }

            // Make sure we Cometary.Core can be loaded
            context.RegisterCompilationStartAction(RegisterAction);

            // Create a matching CometaryManager
            context.RegisterCompilationStartAction(StartAction);

            // Logs a message on success
            context.RegisterCompilationAction(EndAction);
        }

19 Source : PXDiagnosticAnalyzer.cs
with GNU General Public License v3.0
from Acumatica

public override void Initialize(replacedysisContext context)
		{
			AreplacedinatorVsixPackageLoader.EnsurePackageLoaded();

			if (!_settingsProvidedExternally)
				CodereplacedysisSettings = replacedyzersOutOfProcessSettingsProvider.GetCodereplacedysisSettings(); //Initialize settings from global values after potential package load

			if (!CodereplacedysisSettings.StaticreplacedysisEnabled)
				return;

			context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
			context.EnableConcurrentExecution();

			context.RegisterCompilationStartAction(compilationStartContext =>
			{
				var pxContext = new PXContext(compilationStartContext.Compilation, CodereplacedysisSettings);

				if (Shouldreplacedyze(pxContext))
				{
					replacedyzeCompilation(compilationStartContext, pxContext);
				}
			});
		}

19 Source : ClassNameAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            ClreplacedNamereplacedyzer clreplacedNamereplacedyzer = new ClreplacedNamereplacedyzer();
            context.RegisterCompilationStartAction(compilation =>
            {
                compilation.RegisterSyntaxNodeAction(clreplacedNamereplacedyzer.FindClreplacedDeclaration, SyntaxKind.ClreplacedDeclaration);
                compilation.RegisterSyntaxNodeAction(clreplacedNamereplacedyzer.FindEnreplacedyTrigger, SyntaxKind.Attribute);

                compilation.RegisterCompilationEndAction(clreplacedNamereplacedyzer.ReportDiagnostics);
            });
        }

19 Source : DispatchEntityNameAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            DispatchEnreplacedyNamereplacedyzer dispatchreplacedyzer = new DispatchEnreplacedyNamereplacedyzer();
            context.RegisterCompilationStartAction(compilation =>
            {
                compilation.RegisterSyntaxNodeAction(dispatchreplacedyzer.replacedyzeDispatchAndFindMethodDeclarations, SyntaxKind.SimpleMemberAccessExpression);

                compilation.RegisterCompilationEndAction(dispatchreplacedyzer.RegisterStaticreplacedyzer);
            });
        }

19 Source : FunctionAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            Functionreplacedyzer functionreplacedyzer = new Functionreplacedyzer();
            functionreplacedyzer.orchestratorMethodCollector = new OrchestratorMethodCollector();

            context.RegisterCompilationStartAction(compilation =>
            {
                compilation.RegisterSyntaxNodeAction(functionreplacedyzer.orchestratorMethodCollector.FindOrchestratorMethods, SyntaxKind.MethodDeclaration);
                compilation.RegisterSyntaxNodeAction(functionreplacedyzer.FindActivityFunctionDefinition, SyntaxKind.Attribute);

                compilation.RegisterCompilationEndAction(functionreplacedyzer.CompilationEndActions);
            });
        }

19 Source : InterfaceAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            Interfacereplacedyzer interfacereplacedyzer = new Interfacereplacedyzer();

            context.RegisterCompilationStartAction(compilation =>
            {
                compilation.RegisterSyntaxNodeAction(interfacereplacedyzer.FindEnreplacedyCalls, SyntaxKind.SimpleMemberAccessExpression);

                compilation.RegisterCompilationEndAction(interfacereplacedyzer.Registerreplacedyzers);
            });
        }

19 Source : DeterministicMethodAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            orchestratorMethodCollector = new OrchestratorMethodCollector();

            context.RegisterCompilationStartAction(compilation =>
            {
                compilation.RegisterSyntaxNodeAction(orchestratorMethodCollector.FindOrchestratorMethods, SyntaxKind.MethodDeclaration);

                compilation.RegisterCompilationEndAction(Registerreplacedyzers);
            });
        }

19 Source : TaskCompletionSourceAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context) 
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.EnableConcurrentExecution();
            context.RegisterCompilationStartAction(CompilationStart);
        }

19 Source : AsyncAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.EnableConcurrentExecution();
            context.RegisterCompilationStartAction(CompilationStart);
        }

19 Source : RequiredPropertiesInitializationAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterCompilationStartAction(compilationContext =>
            {
                if (LanguageFeaturesAvailability.ImplicitObjectCreation == false)
                {
                    var config = DefaultSettings ?? compilationContext.Options.GetConfigFor<CSE001Settings>(DiagnosticId, compilationContext.CancellationToken);

                    compilationContext.RegisterSyntaxNodeAction(replacedysisContext => replacedyzeObjectCreationSyntax(replacedysisContext, config), SyntaxKind.ObjectCreationExpression);
                    compilationContext.RegisterSyntaxNodeAction(replacedysisContext => replacedyzeObjectInitSyntax(replacedysisContext, config), SyntaxKind.ObjectInitializerExpression);
                }
            });
            
        }

19 Source : ReturnValueUnusedAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterCompilationStartAction(compilationContext =>
            {
                var config = compilationContext.Options.GetConfigFor<CSE005Settings>(DiagnosticId, compilationContext.CancellationToken);
                compilationContext.RegisterSyntaxNodeAction(ctx => replacedyzeSyntax(ctx, config), SyntaxKind.InvocationExpression, SyntaxKind.AwaitExpression, SyntaxKind.ObjectCreationExpression);
            });
        }

19 Source : RequiredPropertiesInitializationAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterCompilationStartAction(compilationContext =>
            {
                if (LanguageFeaturesAvailability.ImplicitObjectCreation)
                {
                    var config = DefaultSettings ?? compilationContext.Options.GetConfigFor<CSE001Settings>(DiagnosticId, compilationContext.CancellationToken);

                    compilationContext.RegisterSyntaxNodeAction(replacedysisContext => replacedyzeObjectCreationSyntax(replacedysisContext, config), SyntaxKind.ImplicitObjectCreationExpression);
                    compilationContext.RegisterSyntaxNodeAction(replacedysisContext => replacedyzeObjectCreationSyntax(replacedysisContext, config), SyntaxKind.ObjectCreationExpression);
                    compilationContext.RegisterSyntaxNodeAction(replacedysisContext => replacedyzeObjectInitSyntax(replacedysisContext, config), SyntaxKind.ObjectInitializerExpression);
                }
            });
        }

19 Source : Benchmark.cs
with MIT License
from GuOrg

public override void RegisterCompilationStartAction(Action<CompilationStartreplacedysisContext> action)
                {
                    this.context.RegisterCompilationStartAction(
                        x => this.replacedyzer.CompilationStartActions.Add(new ContextAndAction<CompilationStartreplacedysisContext>(x, action)));
                }

19 Source : SyntaxTreeCacheAnalyzer.cs
with MIT License
from GuOrg

[System.Diagnostics.Codereplacedysis.SuppressMessage("replacedyzerPerformance", "RS1013:Start action has no registered non-end actions.", Justification = "We want it like this here.")]
        public override void Initialize(replacedysisContext context)
        {
#pragma warning disable CA1062 // Validate arguments of public methods
            context.EnableConcurrentExecution();
#pragma warning restore CA1062 // Validate arguments of public methods
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.RegisterCompilationStartAction(x =>
            {
                var transaction = SyntaxTreeCache<SemanticModel>.Begin(x.Compilation);
                x.RegisterCompilationEndAction(_ => transaction.Dispose());
            });
        }

19 Source : StatechartAnalyzer.cs
with MIT License
from innerspacetrainings

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.RegisterCompilationStartAction(replacedyzeCompilation);
        }

19 Source : PassByReadonlyRefAnalyzer.cs
with GNU Affero General Public License v3.0
from john-h-k

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.EnableConcurrentExecution();

            context.RegisterCompilationStartAction(comp => InitializeCompilation(comp));
        }

19 Source : MartenAnalyzer.cs
with MIT License
from jokokko

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var martenCtx = new MartenContext(ctx.Compilation);

                if (ContextDefined(martenCtx))
                {
                    replacedyzeCompilation(ctx, martenCtx);
                }
            });
        }

19 Source : AnalyzerBase.cs
with MIT License
from kevin-montrose

public sealed override void Initialize(replacedysisContext context)
        {
            // helper for conveniently attaching a debugger
            DoAttachDebugger(AttachDebugger);

            // concurrent for performance sake's, but only if we're not debugging
            if (!AttachDebugger)
            {
                context.EnableConcurrentExecution();
            }

            // ignore generated code
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            // hook up anything that needs to run on compilation start
            context.RegisterCompilationStartAction(
                context =>
                {
                    // grab the state
                    var state = OnCompilationStart(context.Compilation);

                    // visit whatever nodes
                    context.RegisterSyntaxNodeAction(
                        nodeContext =>
                        {
                            OnSyntaxNode(nodeContext, state);
                        },
                        InspectsSyntax
                    );
                }
            );
        }

19 Source : Men002LineTooLong.cs
with MIT License
from menees

public override void Initialize(replacedysisContext context)
		{
			context.RegisterCompilationStartAction(startContext => { this.settings = Settings.Cache(startContext); });
			context.RegisterSyntaxTreeActionHonorExclusions(this.HandleSyntaxTree);
		}

19 Source : Men003MethodTooLong.cs
with MIT License
from menees

public override void Initialize(replacedysisContext context)
		{
			context.RegisterCompilationStartAction(startContext => { this.settings = Settings.Cache(startContext); });
			context.RegisterCodeBlockActionHonorExclusions(this.HandleMethod);
		}

19 Source : Men004PropertyAccessorTooLong.cs
with MIT License
from menees

public override void Initialize(replacedysisContext context)
		{
			context.RegisterCompilationStartAction(startContext => { this.settings = Settings.Cache(startContext); });
			context.RegisterCodeBlockActionHonorExclusions(this.HandleAccessor);
		}

19 Source : Men015UsePreferredTerms.cs
with MIT License
from menees

public override void Initialize(replacedysisContext context)
		{
			context.RegisterCompilationStartAction(startContext => { this.settings = Settings.Cache(startContext); });
			context.RegisterSyntaxTreeActionHonorExclusions(HandleIdentifer);
		}

19 Source : ClassMustBeSealedAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);

                ctx.RegisterSymbolAction(replacedyzerContext.replacedyzeNamedTypeSymbol, SymbolKind.NamedType);
                ctx.RegisterCompilationEndAction(replacedyzerContext.replacedyzeCompilationEnd);
            });
        }

19 Source : ConstructorArgumentParametersShouldExistInConstructorsAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                if (replacedyzerContext.IsValid)
                {
                    ctx.RegisterSymbolAction(replacedyzerContext.replacedyzeProperty, SymbolKind.Property);
                }
            });
        }

19 Source : DoNotNaNInComparisonsAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeBinaryOperator, OperationKind.Binary);
            });
        }

19 Source : DoNotRaiseApplicationExceptionAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var reservedExceptionType = ctx.Compilation.GetTypeByMetadataName("System.ApplicationException");
                if (reservedExceptionType != null)
                {
                    ctx.RegisterOperationAction(_ => replacedyze(_, reservedExceptionType), OperationKind.Throw);
                }
            });
        }

19 Source : DoNotRaiseNotImplementedExceptionAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var compilation = ctx.Compilation;
                var type = compilation.GetTypeByMetadataName("System.NotImplementedException");

                if (type != null)
                {
                    ctx.RegisterOperationAction(_ => replacedyze(_, type), OperationKind.Throw);
                }
            });
        }

19 Source : DoNotRaiseReservedExceptionTypeAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var compilation = ctx.Compilation;
                var reservedExceptionTypes = new List<INamedTypeSymbol>();
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.AccessViolationException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.BadImageFormatException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.CannotUnloadAppDomainException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.DataMisalignedException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.ExecutionEngineException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.IndexOutOfRangeException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.InvalidProgramException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.NullReferenceException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.OutOfMemoryException"));
                reservedExceptionTypes.AddIfNotNull(compilation.GetTypeByMetadataName("System.StackOverflowException"));

                if (reservedExceptionTypes.Any())
                {
                    ctx.RegisterOperationAction(_ => replacedyze(_, reservedExceptionTypes), OperationKind.Throw);
                }
            });
        }

19 Source : DoNotUseDefaultEqualsOnValueTypeAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzeContext = new Context(ctx.Compilation);
                ctx.RegisterOperationAction(replacedyzeContext.replacedyzeInvocationOperation, OperationKind.Invocation);
                ctx.RegisterOperationAction(replacedyzeContext.replacedyzeFieldReferenceOperation, OperationKind.FieldReference);
                ctx.RegisterOperationAction(replacedyzeContext.replacedyzeObjectCreationOperation, OperationKind.ObjectCreation);
            });
        }

19 Source : DoNotUseEqualityOperatorsForSpanOfCharAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var spanOfString = ctx.Compilation.GetTypeByMetadataName("System.Span`1")?.Construct(ctx.Compilation.GetSpecialType(SpecialType.System_Char));
                var readOnlySpanOfString = ctx.Compilation.GetTypeByMetadataName("System.ReadOnlySpan`1")?.Construct(ctx.Compilation.GetSpecialType(SpecialType.System_Char));
                if (spanOfString is null && readOnlySpanOfString is null)
                    return;

                var replacedyzerContext = new replacedyzerContext(spanOfString, readOnlySpanOfString);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeBinaryOperator, OperationKind.BinaryOperator);
            });
        }

19 Source : DoNotUseServerCertificateValidationCallbackAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var symbols = new List<ISymbol>();

                var servicePointManagerSymbol = ctx.Compilation.GetTypeByMetadataName("System.Net.ServicePointManager");
                if (servicePointManagerSymbol != null)
                {
                    symbols.AddIfNotNull(servicePointManagerSymbol.GetMembers("ServerCertificateValidationCallback").FirstOrDefault());
                }

                var httpClientHandlerSymbol = ctx.Compilation.GetTypeByMetadataName("System.Net.Http.HttpClientHandler");
                if (httpClientHandlerSymbol != null)
                {
                    symbols.AddIfNotNull(httpClientHandlerSymbol.GetMembers("ServerCertificateCustomValidationCallback").FirstOrDefault());
                }

                if (symbols.Any())
                {
                    ctx.RegisterOperationAction(c => replacedyze(c, symbols), OperationKind.PropertyReference);
                }
            });
        }

19 Source : EqualityShouldBeCorrectlyImplementedAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                ctx.RegisterSymbolAction(replacedyzerContext.replacedyzeSymbol, SymbolKind.NamedType);
            });
        }

19 Source : MakeClassStaticAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);

                ctx.RegisterSymbolAction(replacedyzerContext.replacedyzeNamedTypeSymbol, SymbolKind.NamedType);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeObjectCreation, OperationKind.ObjectCreation);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeInvocation, OperationKind.Invocation);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeArrayCreation, OperationKind.ArrayCreation);
                ctx.RegisterCompilationEndAction(replacedyzerContext.replacedyzeCompilationEnd);
            });
        }

19 Source : NamedParameterAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(compilationContext =>
            {
                var attributeTokenType = compilationContext.Compilation.GetTypeByMetadataName("SkipNamedAttribute");

                var objectType = compilationContext.Compilation.GetSpecialType(SpecialType.System_Object);
                var taskTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task");
                var taskGenericTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task`1");
                var valueTaskTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Threading.Tasks.ValueTask");
                var valueTaskGenericTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Threading.Tasks.ValueTask`1");
                var taskCompletionSourceType = compilationContext.Compilation.GetTypeByMetadataName("System.Threading.Tasks.TaskCompletionSource`1");
                var methodBaseTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Reflection.MethodBase");
                var fieldInfoTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Reflection.FieldInfo");
                var propertyInfoTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Reflection.PropertyInfo");
                var msTestreplacedertTokenType = compilationContext.Compilation.GetTypeByMetadataName("Microsoft.VisualStudio.TestTools.UnitTesting.replacedert");
                var nunitreplacedertTokenType = compilationContext.Compilation.GetTypeByMetadataName("NUnit.Framework.replacedert");
                var xunitreplacedertTokenType = compilationContext.Compilation.GetTypeByMetadataName("Xunit.replacedert");
                var keyValuePairTokenType = compilationContext.Compilation.GetTypeByMetadataName("System.Collection.Generic.KeyValuePair`2");
                var propertyBuilderType = compilationContext.Compilation.GetTypeByMetadataName("Microsoft.EnreplacedyFrameworkCore.Metadata.Builders.PropertyBuilder`1");
                var syntaxNodeType = compilationContext.Compilation.GetTypeByMetadataName("Microsoft.Codereplacedysis.SyntaxNode");

                compilationContext.RegisterSyntaxNodeAction(syntaxContext =>
                {
                    var argument = (ArgumentSyntax)syntaxContext.Node;
                    if (argument.NameColon != null)
                        return;

                    if (argument.Expression == null)
                        return;

                    var expression = argument.Expression;
                    if (expression.IsKind(SyntaxKind.NullLiteralExpression))
                    {
                        if (!GetConfiguration(syntaxContext.Options, expression).HasFlag(ArgumentExpressionKinds.Null))
                            return;
                    }
                    else if (expression.IsKind(SyntaxKind.NumerireplacederalExpression))
                    {
                        if (!GetConfiguration(syntaxContext.Options, expression).HasFlag(ArgumentExpressionKinds.Numeric))
                            return;
                    }
                    else if (IsBooleanExpression(expression))
                    {
                        if (!GetConfiguration(syntaxContext.Options, expression).HasFlag(ArgumentExpressionKinds.Boolean))
                            return;
                    }
                    else if (IsStringExpression(expression))
                    {
                        if (!GetConfiguration(syntaxContext.Options, expression).HasFlag(ArgumentExpressionKinds.String))
                            return;
                    }
                    else
                    {
                        return;
                    }

                    // Exclude in some methods such as ConfigureAwait(false)
                    var invocationExpression = argument.FirstAncestorOrSelf<InvocationExpressionSyntax>();
                    if (invocationExpression != null)
                    {
                        var methodSymbol = (IMethodSymbol?)syntaxContext.SemanticModel.GetSymbolInfo(invocationExpression).Symbol;
                        if (methodSymbol != null)
                        {
                            var argumentIndex = ArgumentIndex(argument);

                            if (methodSymbol.Parameters.Length == 1 && methodSymbol.Name.StartsWith("Is", StringComparison.Ordinal))
                                return;

                            if (methodSymbol.Parameters.Length == 1 && methodSymbol.Name.StartsWith("Enable", StringComparison.Ordinal))
                                return;

                            if (methodSymbol.Parameters.Length == 1 && methodSymbol.Name == nameof(Task.ConfigureAwait))
                                return;

                            if (IsMethod(methodSymbol, objectType, nameof(object.Equals)))
                                return;

                            if (IsMethod(methodSymbol, objectType, nameof(object.ReferenceEquals)))
                                return;

                            if (IsMethod(methodSymbol, taskTokenType, nameof(Task.FromResult)))
                                return;

                            if (IsMethod(methodSymbol, taskCompletionSourceType, nameof(TaskCompletionSource<object>.SetResult)))
                                return;

                            if (IsMethod(methodSymbol, taskCompletionSourceType, nameof(TaskCompletionSource<object>.TrySetResult)))
                                return;

                            if (IsMethod(methodSymbol, methodBaseTokenType, nameof(MethodBase.Invoke)) && argumentIndex == 0)
                                return;

                            if (IsMethod(methodSymbol, fieldInfoTokenType, nameof(FieldInfo.SetValue)) && argumentIndex == 0)
                                return;

                            if (IsMethod(methodSymbol, fieldInfoTokenType, nameof(FieldInfo.GetValue)) && argumentIndex == 0)
                                return;

                            if (IsMethod(methodSymbol, propertyInfoTokenType, nameof(PropertyInfo.SetValue)) && argumentIndex == 0)
                                return;

                            if (IsMethod(methodSymbol, propertyInfoTokenType, nameof(PropertyInfo.GetValue)) && argumentIndex == 0)
                                return;

                            if (IsMethod(methodSymbol, msTestreplacedertTokenType, "*"))
                                return;

                            if (IsMethod(methodSymbol, nunitreplacedertTokenType, "*"))
                                return;

                            if (IsMethod(methodSymbol, xunitreplacedertTokenType, "*"))
                                return;

                            if ((string.Equals(methodSymbol.Name, "Parse", StringComparison.Ordinal) || string.Equals(methodSymbol.Name, "TryParse", StringComparison.Ordinal)) && argumentIndex == 0)
                                return;

                            // e.g. SyntaxNode.WithElse
                            if (methodSymbol.Name.StartsWith("With", StringComparison.Ordinal) && methodSymbol.ContainingType.IsOrInheritFrom(syntaxNodeType))
                                return;

                            var operation = syntaxContext.SemanticModel.GetOperation(argument, syntaxContext.CancellationToken);
                            if (operation != null && operation.IsInExpressionArgument())
                                return;

                            if (syntaxContext.Options.TryGetConfigurationValue(expression.SyntaxTree, RuleIdentifiers.UseNamedParameter + ".excluded_methods_regex", out var excludedMethodsRegex))
                            {
                                var declarationId = DoreplacedentationCommentId.CreateDeclarationId(methodSymbol);
                                if (Regex.IsMatch(declarationId, excludedMethodsRegex))
                                    return;
                            }

                            if (syntaxContext.Options.TryGetConfigurationValue(expression.SyntaxTree, RuleIdentifiers.UseNamedParameter + ".excluded_methods", out var excludedMethods))
                            {
                                var types = excludedMethods.Split('|');
                                foreach (var type in types)
                                {
                                    var declarationId = DoreplacedentationCommentId.CreateDeclarationId(methodSymbol);
                                    if (type == declarationId)
                                        return;
                                }
                            }
                        }
                    }

                    syntaxContext.ReportDiagnostic(s_rule, syntaxContext.Node);

                    static bool IsBooleanExpression(SyntaxNode node) => node.IsKind(SyntaxKind.TrueLiteralExpression) || node.IsKind(SyntaxKind.FalseLiteralExpression);
                    static bool IsStringExpression(SyntaxNode node) => node.IsKind(SyntaxKind.StringLiteralExpression) || node.IsKind(SyntaxKind.InterpolatedStringExpression);
                }, SyntaxKind.Argument);
            });
        }

19 Source : NotNullIfNotNullArgumentShouldExistAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.ReportDiagnostics);

            context.RegisterCompilationStartAction(ctx =>
            {
                var type = ctx.Compilation.GetTypeByMetadataName("System.Diagnostics.Codereplacedysis.NotNullIfNotNullAttribute");
                if (type == null)
                    return;

                ctx.RegisterSymbolAction(symbolContext => replacedyzeMethod(symbolContext, type), SymbolKind.Method);
            });
        }

19 Source : ObsoleteAttributesShouldIncludeExplanationsAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.ReportDiagnostics);

            context.RegisterCompilationStartAction(ctx =>
            {
                var type = ctx.Compilation.GetTypeByMetadataName("System.ObsoleteAttribute");
                if (type == null)
                    return;

                ctx.RegisterSymbolAction(symbolContext => replacedyzeMethod(symbolContext, type), SymbolKind.Method);
            });
        }

19 Source : TypesShouldNotExtendSystemApplicationExceptionAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var compilation = ctx.Compilation;
                var type = compilation.GetTypeByMetadataName("System.ApplicationException");

                if (type != null)
                {
                    ctx.RegisterSymbolAction(_ => replacedyze(_, type), SymbolKind.NamedType);
                }
            });
        }

19 Source : UseAnOverloadThatHaveCancellationTokenAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                if (replacedyzerContext.CancellationTokenSymbol == null)
                    return;

                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeInvocation, OperationKind.Invocation);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeLoop, OperationKind.Loop);
            });
        }

19 Source : UseConfigureAwaitAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.ReportDiagnostics);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                ctx.RegisterSyntaxNodeAction(replacedyzerContext.replacedyzeAwaitExpression, SyntaxKind.AwaitExpression);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeForEachStatement, OperationKind.Loop);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeUsingOperation, OperationKind.Using);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeUsingDeclarationOperation, OperationKind.UsingDeclaration);
            });
        }

19 Source : UseGuidEmptyAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(compilationContext =>
            {
                compilationContext.RegisterOperationAction(replacedyzeObjectCreationOperation, OperationKind.ObjectCreation);
            });
        }

19 Source : DoNotUseBlockingCallInAsyncContextAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new Context(ctx.Compilation);
                if (replacedyzerContext.IsValid)
                {
                    ctx.RegisterOperationAction(replacedyzerContext.replacedyzeInvocation, OperationKind.Invocation);
                    ctx.RegisterOperationAction(replacedyzerContext.replacedyzePropertyReference, OperationKind.PropertyReference);
                    ctx.RegisterOperationAction(replacedyzerContext.replacedyzeUsing, OperationKind.Using);
                    ctx.RegisterOperationAction(replacedyzerContext.replacedyzeUsingDeclaration, OperationKind.UsingDeclaration);
                }
            });
        }

19 Source : MakeMethodStaticAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext();

                ctx.RegisterSyntaxNodeAction(replacedyzerContext.replacedyzeMethod, SyntaxKind.MethodDeclaration);
                ctx.RegisterSyntaxNodeAction(replacedyzerContext.replacedyzeProperty, SyntaxKind.PropertyDeclaration);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeDelegateCreation, OperationKind.DelegateCreation);
                ctx.RegisterCompilationEndAction(replacedyzerContext.CompilationEnd);
            });
        }

19 Source : UseArrayEmptyAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(compilationContext =>
            {
                var typeSymbol = compilationContext.Compilation.GetTypeByMetadataName("System.Array");
                if (typeSymbol == null || typeSymbol.DeclaredAccessibility != Accessibility.Public)
                    return;

                if (typeSymbol.GetMembers("Empty").FirstOrDefault() is IMethodSymbol methodSymbol &&
                    methodSymbol.DeclaredAccessibility == Accessibility.Public &&
                    methodSymbol.IsStatic && methodSymbol.Arity == 1 && methodSymbol.Parameters.Length == 0)
                {
                    compilationContext.RegisterOperationAction(replacedyzeArrayCreationOperation, OperationKind.ArrayCreation);
                }
            });
        }

19 Source : UseEventHandlerOfTAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                ctx.RegisterSymbolAction(replacedyzerContext.replacedyzeSymbol, SymbolKind.Event);
            });
        }

19 Source : OptionalParametersAttributeAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                if (replacedyzerContext.IsValid)
                {
                    ctx.RegisterSymbolAction(replacedyzerContext.replacedyzerParameter, SymbolKind.Parameter);
                }
            });
        }

19 Source : PreferReturnCollectionAbstractionInsteadOfImplementationAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);

                ctx.RegisterSyntaxNodeAction(c => replacedyzerContext.replacedyzeDelegate(c), SyntaxKind.DelegateDeclaration);
                ctx.RegisterSyntaxNodeAction(c => replacedyzerContext.replacedyzeField(c), SyntaxKind.FieldDeclaration);
                ctx.RegisterSyntaxNodeAction(c => replacedyzerContext.replacedyzeIndexer(c), SyntaxKind.IndexerDeclaration);
                ctx.RegisterSyntaxNodeAction(c => replacedyzerContext.replacedyzeMethod(c), SyntaxKind.MethodDeclaration);
                ctx.RegisterSyntaxNodeAction(c => replacedyzerContext.replacedyzeProperty(c), SyntaxKind.PropertyDeclaration);
            });
        }

19 Source : UseStructLayoutAttributeAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(compilationContext =>
            {
                var attributeType = compilationContext.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.StructLayoutAttribute");
                if (attributeType == null)
                    return;

                compilationContext.RegisterSymbolAction(replacedyze, SymbolKind.NamedType);
            });
        }

19 Source : ValidateArgumentsCorrectlyAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var compilation = ctx.Compilation;
                var replacedyzerContext = new replacedyzerContext(compilation);

                ctx.RegisterSyntaxNodeAction(replacedyzerContext.replacedyzeMethodDeclaration, SyntaxKind.MethodDeclaration);
            });
        }

19 Source : OptimizeStartsWithAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                if (replacedyzerContext.IsValid)
                {
                    ctx.RegisterOperationAction(replacedyzerContext.replacedyzeInvocation, OperationKind.Invocation);
                }
            });
        }

19 Source : UseStringComparerAnalyzer.cs
with MIT License
from meziantou

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);

            context.RegisterCompilationStartAction(ctx =>
            {
                var replacedyzerContext = new replacedyzerContext(ctx.Compilation);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeConstructor, OperationKind.ObjectCreation);
                ctx.RegisterOperationAction(replacedyzerContext.replacedyzeInvocation, OperationKind.Invocation);
            });
        }

See More Examples