Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.ConfigureGeneratedCodeAnalysis(Microsoft.CodeAnalysis.Diagnostics.GeneratedCodeAnalysisFlags)

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

387 Examples 7

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 : AG0003HttpContextCannotBePassedAsMethodArgument.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(replacedyzeNode, SyntaxKind.Parameter);
        }

19 Source : AG0020AvoidReturningNullEnumerables.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(replacedyzeNode, new[] {
                SyntaxKind.ReturnStatement,
                SyntaxKind.ArrowExpressionClause,
                SyntaxKind.ConditionalExpression
            });
        }

19 Source : AG0021PreferAsyncMethods.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(replacedyzeNode, SyntaxKind.InvocationExpression);
        }

19 Source : AG0022DoNotExposeBothSyncAndAsyncVersionsOfMethods.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(replacedyzeNode, SyntaxKind.MethodDeclaration);
        }

19 Source : SA1106CodeMustNotContainEmptyStatements.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(EmptyStatementAction, SyntaxKind.EmptyStatement);
            context.RegisterSyntaxNodeAction(BaseTypeDeclarationAction, SyntaxKinds.BaseTypeDeclaration);
            context.RegisterSyntaxNodeAction(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
        }

19 Source : SA1107CodeMustNotContainMultipleStatementsOnOneLine.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(BlockAction, SyntaxKind.Block);
        }

19 Source : SA1123DoNotPlaceRegionsWithinElements.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(RegionDirectiveTriviaAction, SyntaxKind.RegionDirectiveTrivia);
        }

19 Source : AG0038PreventUseOfRegionPreprocessorDirective.cs
with Apache License 2.0
from agoda-com

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

            context.RegisterSyntaxNodeAction(replacedyzeNode, SyntaxKind.RegionDirectiveTrivia);
        }

19 Source : AssignAllAnalyzer.cs
with MIT License
from angularsen

public override void Initialize(replacedysisContext ctx)
        {
            ctx.EnableConcurrentExecution();
            ctx.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None); // Don't touch code clreplacedified as generated
            ctx.RegisterCodeBlockStartAction<SyntaxKind>(RegisterObjectInitializerreplacedyzerOnCodeBlockStart);
        }

19 Source : EitherAbstractOrSealed.cs
with MIT License
from asc-community

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

            context.RegisterSymbolAction(symbolContext =>
            {
                var typeDecl = (INamedTypeSymbol)symbolContext.Symbol;
                var containingType = typeDecl.ContainingType;
                if (!typeDecl.IsAbstract && !typeDecl.IsSealed && !typeDecl.IsStatic)
                {
                    var diag = Diagnostic.Create(Rule, typeDecl.Locations.First());
                    symbolContext.ReportDiagnostic(diag);
                }
            }, SymbolKind.NamedType);
        }

19 Source : StaticFieldThreadSafety.cs
with MIT License
from asc-community

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

            context.RegisterSymbolAction(symbolContext =>
            {
                var fieldDecl = (IFieldSymbol)symbolContext.Symbol;
                var hasConstantFieldAttribute = fieldDecl.GetAttributes().Any(attr => attr.AttributeClreplaced?.Name == "ConstantFieldAttribute");
                var hasThreadStaticAttribute = fieldDecl.GetAttributes().Any(attr => attr.AttributeClreplaced?.Name == "ThreadStaticAttribute");
                var hasConcurrentFieldAttribute = fieldDecl.GetAttributes().Any(attr => attr.AttributeClreplaced?.Name == "ConcurrentFieldAttribute");
                if (fieldDecl.IsStatic && 
                    !fieldDecl.IsConst && 
                    !hasThreadStaticAttribute
                    &&
                    !hasConstantFieldAttribute
                    &&
                    !hasConcurrentFieldAttribute
                    &&
                    fieldDecl.Type.Name != "ConditionalWeakTable"
                    )
                {
                    var diag = Diagnostic.Create(RuleAddAttribute, fieldDecl.Locations.First());
                    symbolContext.ReportDiagnostic(diag);
                }
                if (hasThreadStaticAttribute)
                {
                    var syntaxTree = fieldDecl.DeclaringSyntaxReferences.First().GetSyntax();
                    if (syntaxTree is VariableDeclaratorSyntax variableDeclarator)
                    {
                        if (variableDeclarator.Initializer is not null)
                        {
                            var diag = Diagnostic.Create(RuleShouldBeNull, fieldDecl.Locations.First());
#pragma warning disable RS1005 // ReportDiagnostic invoked with an unsupported DiagnosticDescriptor
                            symbolContext.ReportDiagnostic(diag);
#pragma warning restore RS1005 // ReportDiagnostic invoked with an unsupported DiagnosticDescriptor
                        }
                    }

19 Source : AsyncVoidAnalyzer.cs
with MIT License
from Azure

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

            context.RegisterSymbolAction(replacedyzeMethod, SymbolKind.Method);
        }

19 Source : WebJobsAttributesNotSupported.cs
with MIT License
from Azure

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

            context.RegisterSymbolAction(c =>
            {
                var symbol = (IMethodSymbol)c.Symbol;

                var attributes = symbol.GetAttributes();

                if (attributes.IsEmpty)
                {
                    return;
                }

                if (symbol.IsFunction(c))
                {
                    var webjobsAttributes = symbol.GetWebJobsAttributes();
                    foreach (var attribute in webjobsAttributes)
                    {
                        var location = Location.Create(attribute.ApplicationSyntaxReference.SyntaxTree, attribute.ApplicationSyntaxReference.Span);
                        c.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.WebJobsAttributesAreNotSuppoted, location, attribute.AttributeClreplaced.Name));
                    }
                }
            }, SymbolKind.Method);
        }

19 Source : EntityContextAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.EnableConcurrentExecution();
            context.RegisterSyntaxNodeAction(FindEnreplacedyTriggers, SyntaxKind.Attribute);
        }

19 Source : OrchestratorContextAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.RegisterSyntaxNodeAction(FindOrchestrationTriggers, SyntaxKind.Attribute);
        }

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 : ClientAnalyzer.cs
with MIT License
from Azure

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.RegisterSyntaxNodeAction(FindEnreplacedyTriggers, SyntaxKind.Attribute);
        }

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 : 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 : 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 : SymbolAnalyzerBase.cs
with MIT License
from Azure

public sealed override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.EnableConcurrentExecution();
            context.RegisterSymbolAction(c => replacedyze(new RoslynSymbolreplacedysisContext(c)), SymbolKinds);
        }

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 : ClientAssemblyAttributesAnalyzer.cs
with MIT License
from Azure

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

19 Source : MethodPropertyAnalyzer.cs
with MIT License
from byme8

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.RegisterSyntaxNodeAction(Handle, SyntaxKind.InvocationExpression);
        }

19 Source : DontUseKeyOfConstructorAnalyzer.cs
with MIT License
from byme8

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.RegisterSyntaxNodeAction(Handle, SyntaxKind.ObjectCreationExpression);
        }

19 Source : IndexPropertyAnalyzer.cs
with MIT License
from byme8

public override void Initialize(replacedysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.replacedyze | GeneratedCodereplacedysisFlags.ReportDiagnostics);
            context.RegisterSyntaxNodeAction(Handle, SyntaxKind.ElementAccessExpression);
        }

19 Source : ExpressionTooComplexAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterSyntaxNodeAction(replacedyzeSyntax, SyntaxKind.InvocationExpression, SyntaxKind.ObjectCreationExpression);
        }

19 Source : AbandonLockAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));

            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterSyntaxNodeAction(replacedyzeMonitorMethodInvocation, SyntaxKind.InvocationExpression);
        }

19 Source : BasicLockAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));

            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterSyntaxNodeAction(replacedyzeLockStatement, SyntaxKind.LockStatement);
            context.RegisterSyntaxNodeAction(replacedyzeMonitorEnterInvocation, SyntaxKind.InvocationExpression);
        }

19 Source : CopiedSpinLockAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));

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

            context.RegisterSyntaxNodeAction(replacedyzeParameter, SyntaxKind.Parameter);
            context.RegisterSyntaxNodeAction(replacedyzeField, SyntaxKind.FieldDeclaration);
            context.RegisterSyntaxNodeAction(replacedyzeProperty, SyntaxKind.PropertyDeclaration);
        }

19 Source : DeprecatedReaderWriterLockAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));

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

            context.RegisterSyntaxNodeAction(replacedyzeField, SyntaxKind.FieldDeclaration);
            context.RegisterSyntaxNodeAction(replacedyzeProperty, SyntaxKind.PropertyDeclaration);
        }

19 Source : MethodLevelSynchronizationAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));

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

            context.RegisterSyntaxNodeAction(replacedyzeMethodAttributes, SyntaxKind.Attribute);
        }

19 Source : InitOnlyAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterSyntaxNodeAction(replacedyzeSyntax, SyntaxKind.SimplereplacedignmentExpression);
        }

19 Source : InitOnlyOptionalAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterSyntaxNodeAction(replacedyzeSyntax, SyntaxKind.PropertyDeclaration, SyntaxKind.FieldDeclaration);
        }

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 : TwinTypeAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterSymbolAction(replacedyzeSymbol, SymbolKind.NamedType);
        }

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 : MacroCodeAnalyzer.cs
with MIT License
from cezarypiatek

public override void Initialize(replacedysisContext context)
        {
            context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
            context.RegisterSyntaxTreeAction(replacedyzeComment);
        }

19 Source : ExceptionDrivenLogicAnalyzer.cs
with MIT License
from cezarypiatek

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

            context.RegisterSyntaxNodeAction((syntaxNodeContext) =>
            {
                var tryStatement = (TryStatementSyntax) syntaxNodeContext.Node;

                if (tryStatement.Catches.Count == 0)
                {
                    return;
                }

                var allThrowExpressions = GetAllThrowExpressionsInfo(tryStatement.Block, syntaxNodeContext);

                if (allThrowExpressions.Count == 0)
                {
                    return;
                }

                foreach (var catchClauseSyntax in tryStatement.Catches)
                {
                    if (catchClauseSyntax.Declaration == null)
                    {
                        ReportViolationForExpressions(allThrowExpressions, syntaxNodeContext);
                        break;
                    }

                    var catchTypeInfo = syntaxNodeContext.SemanticModel.GetTypeInfo(catchClauseSyntax.Declaration.Type);
                    var expressionsToReport = allThrowExpressions.Where(throwExpression => throwExpression.Reported == false && throwExpression.Type.IsreplacedignableToType(catchTypeInfo.Type));
                    ReportViolationForExpressions(expressionsToReport, syntaxNodeContext);
                }

            }, SyntaxKind.TryStatement);

        }

19 Source : ProvideInnerExceptionInCatchAnalyzer.cs
with MIT License
from cezarypiatek

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

            context.RegisterSyntaxNodeAction(syntaxNodeContext =>
            {
                var catchClause = (CatchClauseSyntax) syntaxNodeContext.Node;
                var exceptionVariable = catchClause.Declaration?.Identifier.Text;
                var allExpressions = catchClause.Block.GetAllThrowExpressions();

                if (allExpressions.Count == 0)
                {
                    return;
                }

                foreach (var expression in allExpressions)
                {
                    if (expression is ObjectCreationExpressionSyntax objectCreationExpression)
                    {
                        TryToReportDiagnostic(objectCreationExpression.ArgumentList, exceptionVariable, syntaxNodeContext, objectCreationExpression);
                    }
                    else if (expression is InvocationExpressionSyntax invocationExpressionSyntax)
                    {
                        TryToReportDiagnostic(invocationExpressionSyntax.ArgumentList, exceptionVariable, syntaxNodeContext, invocationExpressionSyntax);
                    }
                }


            }, SyntaxKind.CatchClause);
        }

19 Source : ThrowExpressionBaseAnalyzer.cs
with MIT License
from cezarypiatek

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

            context.RegisterSyntaxNodeAction(syntaxNodeContext =>
            {
                var throwStatement = (ThrowStatementSyntax)syntaxNodeContext.Node;
                replacedyzeThrowSubExpression(syntaxNodeContext, throwStatement.Expression);
            }, SyntaxKind.ThrowStatement);

            context.RegisterSyntaxNodeAction(syntaxNodeContext =>
            {
                var throwExpression = (ThrowExpressionSyntax) syntaxNodeContext.Node;
                replacedyzeThrowSubExpression(syntaxNodeContext, throwExpression.Expression);
            }, SyntaxKind.ThrowExpression);
        }

19 Source : ViewAnalyzer.cs
with MIT License
from chkn

public override void Initialize (replacedysisContext context)
		{
			context.ConfigureGeneratedCodereplacedysis (GeneratedCodereplacedysisFlags.None);
			context.EnableConcurrentExecution ();
			context.RegisterSyntaxNodeAction (replacedyzeNode, SyntaxKind.RecordDeclaration);
		}

19 Source : PreferSlimSynchronizationAnalyzer.cs
with GNU General Public License v3.0
from Concurrency-Lab

public override void Initialize(replacedysisContext context) {
      context.EnableConcurrentExecution();
      context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
      context.RegisterSyntaxNodeAction(replacedyzeCandidate, SyntaxKind.ObjectCreationExpression);
    }

19 Source : UnusedCancellationTokenFromEnclosingScopeAnalyzer.cs
with GNU General Public License v3.0
from Concurrency-Lab

public override void Initialize(replacedysisContext context) {
      context.EnableConcurrentExecution();
      context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
      context.RegisterSyntaxNodeAction(replacedyzeMemberAccess, SyntaxKind.ClreplacedDeclaration);
    }

19 Source : LinqToCollectionOnConcurrentDictionaryAnalyzer.cs
with GNU General Public License v3.0
from Concurrency-Lab

public override void Initialize(replacedysisContext context) {
      context.EnableConcurrentExecution();
      context.ConfigureGeneratedCodereplacedysis(GeneratedCodereplacedysisFlags.None);
      context.RegisterSyntaxNodeAction(replacedyzeInvocation, SyntaxKind.InvocationExpression);
    }

19 Source : MonitorWaitConditionUnaffectedAnalyzer.cs
with GNU General Public License v3.0
from Concurrency-Lab

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

See More Examples