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
19
Source : CometaryAnalyzer.cs
with MIT License
from 71
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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