private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodDeclaration, SyntaxKind.MethodDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleDelegateDeclaration, SyntaxKind.DelegateDeclaration);
}
/// <summary>
/// Documentation analysis is done only on compilation start, to delay
/// </summary>
/// <param name="context">the compilation start action.</param>
private void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeAction(
this.HandleClassOrInterfaceDeclaration,
SyntaxKind.InterfaceDeclaration,
SyntaxKind.ClassDeclaration);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.MethodDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.ConstructorDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.DelegateDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.IndexerDeclaration);
}
protected override SymbolAndNodeAnalyzer GetAnalyzer(CompilationStartAnalysisContext context, CompilationSecurityTypes types, Version targetFrameworkVersion)
{
SymbolAndNodeAnalyzer analyzer = new SymbolAndNodeAnalyzer(types, CSharpSyntaxNodeHelper.Default, targetFrameworkVersion);
context.RegisterSyntaxNodeAction(analyzer.AnalyzeNode, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration);
return analyzer;
}
private void AnalyzeCompilationStart(CompilationStartAnalysisContext csContext)
{
// Get named type symbols for targetted exception types
ImmutableHashSet<INamedTypeSymbol> exceptionTypes = s_exceptionTypeNames
.Select(name => csContext.Compilation.GetTypeByMetadataName(name))
.Where(t => t != null)
.ToImmutableHashSet();
if (!exceptionTypes.IsEmpty)
{
// register symbol action for named types
csContext.RegisterSymbolAction(saContext =>
{
var symbol = (INamedTypeSymbol)saContext.Symbol;
// skip public symbols
if (symbol.IsPublic()) return;
// only report if base type matches
if (symbol.BaseType != null && exceptionTypes.Contains(symbol.BaseType))
{
saContext.ReportDiagnostic(symbol.CreateDiagnostic(Rule));
}
},
SymbolKind.NamedType);
}
}
/// <summary>Called once at compilation start to register actions in the compilation context.</summary>
/// <param name="context">The analysis context.</param>
internal void RegisterOperationAction(CompilationStartAnalysisContext context)
{
context.RegisterOperationAction(
(operationContext) =>
{
IArrayCreationExpression arrayCreation = (IArrayCreationExpression)operationContext.Operation;
// ToDo: Need to suppress analysis of array creation expressions within attribute applications.
// Detect array creation expression that have rank 1 and size 0. Such expressions
// can be replaced with Array.Empty<T>(), provided that the element type can be a generic type argument.
if (arrayCreation.DimensionSizes.Length == 1
//// Pointer types can't be generic type arguments.
&& arrayCreation.ElementType.TypeKind != TypeKind.Pointer)
{
Optional<object> arrayLength = arrayCreation.DimensionSizes[0].ConstantValue;
if (arrayLength.HasValue &&
arrayLength.Value is int &&
(int)arrayLength.Value == 0)
{
Report(operationContext, arrayCreation.Syntax);
}
}
},
OperationKind.ArrayCreationExpression);
}
void Analyze(CompilationStartAnalysisContext compilationContext)
{
var compilation = compilationContext.Compilation;
compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext context)
{
try
{
if (!compilation.SyntaxTrees.Contains(context.Tree))
return;
var semanticModel = compilation.GetSemanticModel(context.Tree);
var root = await context.Tree.GetRootAsync(context.CancellationToken).ConfigureAwait(false);
var model = compilationContext.Compilation.GetSemanticModel(context.Tree);
if (model.IsFromGeneratedCode(compilationContext.CancellationToken))
return;
foreach (var type in root.DescendantNodesAndSelf(SkipMembers).OfType<ClassDeclarationSyntax>())
{
var fieldDeclarations = type
.ChildNodes()
.OfType<FieldDeclarationSyntax>()
.Where(f => FieldFilter(model, f))
.SelectMany(fd => fd.Declaration.Variables.Select(v => new { Field = fd, Variable = v, Symbol = semanticModel.GetDeclaredSymbol(v, context.CancellationToken) }));
foreach (var candidateField in fieldDeclarations)
{
context.CancellationToken.ThrowIfCancellationRequested();
// handled by ConvertToConstantIssue
if (candidateField?.Variable?.Initializer != null && semanticModel.GetConstantValue(candidateField.Variable.Initializer.Value, context.CancellationToken).HasValue)
continue;
// user-defined value type -- might be mutable
var field = candidateField.Symbol;
if (field != null && !field.GetReturnType().IsReferenceType)
{
if (field.GetReturnType().IsDefinedInSource())
{
continue;
}
}
bool wasAltered = false;
bool wasUsed = false;
foreach (var member in type.Members)
{
if (member == candidateField.Field)
continue;
if (IsAltered(model, member, candidateField.Symbol, context.CancellationToken, out wasUsed))
{
wasAltered = true;
break;
}
}
if (!wasAltered && wasUsed)
{
context.CancellationToken.ThrowIfCancellationRequested();
context.ReportDiagnostic(Diagnostic.Create(descriptor, candidateField.Variable.Identifier.GetLocation()));
}
}
}
}
catch (Exception) { }
});
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodDeclaration, SyntaxKind.MethodDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleConstructorDeclaration, SyntaxKind.ConstructorDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleInvocationExpression, SyntaxKind.InvocationExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleObjectCreationExpression, SyntaxKind.ObjectCreationExpression);
}
protected override void RegisterImmutableArrayAction(CompilationStartAnalysisContext context, INamedTypeSymbol immutableArrayOfTType)
{
context.RegisterCodeBlockStartAction<SyntaxKind>(
c => c.RegisterSyntaxNodeAction(
c2 => AnalyzeCollectionInitializerExpression(c2, immutableArrayOfTType),
SyntaxKind.CollectionInitializerExpression));
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration,
SyntaxKind.EnumDeclaration, SyntaxKind.DelegateDeclaration, SyntaxKind.FieldDeclaration, SyntaxKind.MethodDeclaration,
SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.EventFieldDeclaration, SyntaxKind.IndexerDeclaration,
SyntaxKind.OperatorDeclaration, SyntaxKind.ConversionOperatorDeclaration, SyntaxKind.ConstructorDeclaration);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(BaseTypeDeclarationAction, BaseTypeDeclarationKinds);
context.RegisterSyntaxNodeActionHonorExclusions(BasePropertyDeclarationAction, BasePropertyDeclarationKinds);
context.RegisterSyntaxNodeActionHonorExclusions(BaseMethodDeclarationAction, BaseMethodDeclarationKinds);
context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
}
private static void AnalyzeCompilationStart(CompilationStartAnalysisContext context)
{
ImmutableHashSet<INamedTypeSymbol> badBaseTypes = s_badBaseTypesToMessage.Keys
.Select(bt => context.Compilation.GetTypeByMetadataName(bt))
.Where(bt => bt != null)
.ToImmutableHashSet();
if (badBaseTypes.Count > 0)
{
context.RegisterSymbolAction((saContext) =>
{
var namedTypeSymbol = saContext.Symbol as INamedTypeSymbol;
if (namedTypeSymbol.BaseType != null && badBaseTypes.Contains(namedTypeSymbol.BaseType))
{
string baseTypeName = namedTypeSymbol.BaseType.ToDisplayString();
Debug.Assert(s_badBaseTypesToMessage.ContainsKey(baseTypeName));
string message = string.Format(s_badBaseTypesToMessage[baseTypeName], namedTypeSymbol.ToDisplayString(), baseTypeName);
Diagnostic diagnostic = Diagnostic.Create(Rule, namedTypeSymbol.Locations.First(), namedTypeSymbol.Locations.Skip(1), message);
saContext.ReportDiagnostic(diagnostic);
}
}
, SymbolKind.NamedType);
}
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseTypeDeclarations, SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.EnumDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandlePropertyLikeDeclarations, SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.IndexerDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodLikeDeclarations, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.DestructorDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclarations, SyntaxKind.NamespaceDeclaration);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
// handle everything except nameof
context.RegisterSyntaxTreeActionHonorExclusions(HandleSyntaxTree);
// handle nameof (which appears as an invocation expression??)
context.RegisterSyntaxNodeActionHonorExclusions(HandleInvocationExpressionSyntax, SyntaxKind.InvocationExpression);
}
protected override Analyzer GetAnalyzer(CompilationStartAnalysisContext context, CompilationSecurityTypes cryptTypes)
{
Analyzer analyzer = new Analyzer(cryptTypes);
context.RegisterSyntaxNodeAction(analyzer.AnalyzeNode,
SyntaxKind.InvocationExpression,
SyntaxKind.ObjectCreationExpression);
return analyzer;
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleIfStatement, SyntaxKind.IfStatement);
context.RegisterSyntaxNodeActionHonorExclusions(HandleDoStatement, SyntaxKind.DoStatement);
context.RegisterSyntaxNodeActionHonorExclusions(HandleWhileStatement, SyntaxKind.WhileStatement);
context.RegisterSyntaxNodeActionHonorExclusions(HandleForStatement, SyntaxKind.ForStatement);
context.RegisterSyntaxNodeActionHonorExclusions(HandleForEachStatement, SyntaxKind.ForEachStatement);
}
private void OnCompilationStart(CompilationStartAnalysisContext context)
{
var immutableArrayType = context.Compilation.GetTypeByMetadataName(ImmutableArrayMetadataName);
if (immutableArrayType != null)
{
context.RegisterSyntaxNodeAction(syntaxContext => AnalyzeCall(syntaxContext, immutableArrayType), SyntaxKind.InvocationExpression);
}
}
public override void OnCompilationStart(CompilationStartAnalysisContext context)
{
SRSymbol = context.Compilation.GetTypeByMetadataName("System.SR");
if (SRSymbol != null)
{
context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.InvocationExpression);
}
}
private void AnalyzeCompilationSymbol(CompilationStartAnalysisContext context)
{
_exceptionType = context.Compilation.GetTypeByMetadataName("System.Exception");
// Analyze named types
context.RegisterSymbolAction(symbolContext =>
{
AnalyzeSymbol(symbolContext);
}, SymbolKind.NamedType);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.EqualsExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.NotEqualsExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.GreaterThanExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.LessThanExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.GreaterThanOrEqualExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.LessThanOrEqualExpression);
}
private void InitializeCore(CompilationStartAnalysisContext context)
{
var objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
var equatableType = context.Compilation.GetTypeByMetadataName(IEquatableMetadataName);
if (objectType != null && equatableType != null)
{
context.RegisterSymbolAction(c => AnalyzeSymbol(c, objectType, equatableType), SymbolKind.NamedType);
}
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleEmptyStatementSyntax, SyntaxKind.EmptyStatement);
context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeSyntax, SyntaxKind.ClassDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeSyntax, SyntaxKind.StructDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeSyntax, SyntaxKind.InterfaceDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeSyntax, SyntaxKind.EnumDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceSyntax, SyntaxKind.NamespaceDeclaration);
}
private static void OnCompilationStart(CompilationStartAnalysisContext context)
{
INamedTypeSymbol objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
INamedTypeSymbol equatableType = context.Compilation.GetTypeByMetadataName(IEquatableMetadataName);
if (objectType != null && equatableType != null)
{
context.RegisterSymbolAction(c => AnalyzeSymbol(c, equatableType), SymbolKind.NamedType);
}
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleBlock, SyntaxKind.Block);
context.RegisterSyntaxNodeActionHonorExclusions(HandleInitializers, SyntaxKind.ObjectInitializerExpression, SyntaxKind.CollectionInitializerExpression, SyntaxKind.ArrayInitializerExpression, SyntaxKind.ComplexElementInitializerExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleAnonymousObjectCreation, SyntaxKind.AnonymousObjectCreationExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleSwitchStatement, SyntaxKind.SwitchStatement);
context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclaration, SyntaxKind.NamespaceDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.EnumDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(HandleAccessorList, SyntaxKind.AccessorList);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(BlockAction, SyntaxKind.Block);
context.RegisterSyntaxNodeActionHonorExclusions(InitializerExpressionAction, SyntaxKinds.InitializerExpression);
context.RegisterSyntaxNodeActionHonorExclusions(AnonymousObjectCreationExpressionAction, SyntaxKind.AnonymousObjectCreationExpression);
context.RegisterSyntaxNodeActionHonorExclusions(SwitchStatementAction, SyntaxKind.SwitchStatement);
context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(BaseTypeDeclarationAction, SyntaxKinds.BaseTypeDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(AccessorListAction, SyntaxKind.AccessorList);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
// Only register the syntax node action if the diagnostic is enabled. This is important because
// otherwise the diagnostic for fading out the parenthesis is still active, even if the main diagnostic
// is disabled
if (context.Compilation.Options.SpecificDiagnosticOptions.GetValueOrDefault(Descriptor.Id) != Microsoft.CodeAnalysis.ReportDiagnostic.Suppress)
{
context.RegisterSyntaxNodeAction(ParenthesizedExpressionAction, SyntaxKind.ParenthesizedExpression);
}
}
private void OnCompilationStart(CompilationStartAnalysisContext context)
{
var listType = context.Compilation.GetTypeByMetadataName(IListMetadataName);
var readonlyListType = context.Compilation.GetTypeByMetadataName(IReadOnlyListMetadataName);
var enumerableType = context.Compilation.GetTypeByMetadataName(EnumerableMetadataName);
if (readonlyListType != null && enumerableType != null && listType != null)
{
context.RegisterSyntaxNodeAction(nodeContext => AnalyzeCall(nodeContext, enumerableType, readonlyListType, listType), SyntaxKind.InvocationExpression);
}
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleMathExpression, SyntaxKind.AddExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMathExpression, SyntaxKind.SubtractExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMathExpression, SyntaxKind.MultiplyExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMathExpression, SyntaxKind.DivideExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMathExpression, SyntaxKind.ModuloExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMathExpression, SyntaxKind.LeftShiftExpression);
context.RegisterSyntaxNodeActionHonorExclusions(HandleMathExpression, SyntaxKind.RightShiftExpression);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleIfStatement, SyntaxKind.IfStatement);
context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((DoStatementSyntax)ctx.Node).Statement), SyntaxKind.DoStatement);
context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((WhileStatementSyntax)ctx.Node).Statement), SyntaxKind.WhileStatement);
context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((ForStatementSyntax)ctx.Node).Statement), SyntaxKind.ForStatement);
context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((ForEachStatementSyntax)ctx.Node).Statement), SyntaxKind.ForEachStatement);
context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((FixedStatementSyntax)ctx.Node).Statement), SyntaxKind.FixedStatement);
context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((UsingStatementSyntax)ctx.Node).Statement), SyntaxKind.UsingStatement);
context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((LockStatementSyntax)ctx.Node).Statement), SyntaxKind.LockStatement);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(BaseTypeDeclarationAction, SyntaxKinds.BaseTypeDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(DelegateDeclarationAction, SyntaxKind.DelegateDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(EventDeclarationAction, SyntaxKind.EventDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(MethodDeclarationAction, SyntaxKind.MethodDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(PropertyDeclarationAction, SyntaxKind.PropertyDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(BaseFieldDeclarationAction, SyntaxKinds.BaseFieldDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(IndexerDeclarationAction, SyntaxKind.IndexerDeclaration);
context.RegisterSyntaxNodeActionHonorExclusions(ConstructorDeclarationAction, SyntaxKind.ConstructorDeclaration);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(CompilationUnitAction, SyntaxKind.CompilationUnit);
context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
}
protected override void InitializeWorker(CompilationStartAnalysisContext context)
{
#region "Get All the WellKnown Types and Members"
var iformatProviderType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemIFormatProvider);
var cultureInfoType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemGlobalizationCultureInfo);
if (iformatProviderType == null || cultureInfoType == null)
{
return;
}
var objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
var stringType = context.Compilation.GetSpecialType(SpecialType.System_String);
var charType = context.Compilation.GetSpecialType(SpecialType.System_Char);
var boolType = context.Compilation.GetSpecialType(SpecialType.System_Boolean);
var guidType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemGuid);
var builder = ImmutableHashSet.CreateBuilder <INamedTypeSymbol>();
builder.AddIfNotNull(charType);
builder.AddIfNotNull(boolType);
builder.AddIfNotNull(stringType);
builder.AddIfNotNull(guidType);
var invariantToStringTypes = builder.ToImmutableHashSet();
var dateTimeType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemDateTime);
var dateTimeOffsetType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemDateTimeOffset);
var timeSpanType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemTimeSpan);
var stringFormatMembers = stringType.GetMembers("Format").OfType <IMethodSymbol>();
var stringFormatMemberWithStringAndObjectParameter = stringFormatMembers.GetFirstOrDefaultMemberWithParameterInfos(
GetParameterInfo(stringType),
GetParameterInfo(objectType));
var stringFormatMemberWithStringObjectAndObjectParameter = stringFormatMembers.GetFirstOrDefaultMemberWithParameterInfos(
GetParameterInfo(stringType),
GetParameterInfo(objectType),
GetParameterInfo(objectType));
var stringFormatMemberWithStringObjectObjectAndObjectParameter = stringFormatMembers.GetFirstOrDefaultMemberWithParameterInfos(
GetParameterInfo(stringType),
GetParameterInfo(objectType),
GetParameterInfo(objectType),
GetParameterInfo(objectType));
var stringFormatMemberWithStringAndParamsObjectParameter = stringFormatMembers.GetFirstOrDefaultMemberWithParameterInfos(
GetParameterInfo(stringType),
GetParameterInfo(objectType, isArray: true, arrayRank: 1, isParams: true));
var stringFormatMemberWithIFormatProviderStringAndParamsObjectParameter = stringFormatMembers.GetFirstOrDefaultMemberWithParameterInfos(
GetParameterInfo(iformatProviderType),
GetParameterInfo(stringType),
GetParameterInfo(objectType, isArray: true, arrayRank: 1, isParams: true));
var currentCultureProperty = cultureInfoType.GetMembers("CurrentCulture").OfType <IPropertySymbol>().FirstOrDefault();
var invariantCultureProperty = cultureInfoType.GetMembers("InvariantCulture").OfType <IPropertySymbol>().FirstOrDefault();
var currentUICultureProperty = cultureInfoType.GetMembers("CurrentUICulture").OfType <IPropertySymbol>().FirstOrDefault();
var installedUICultureProperty = cultureInfoType.GetMembers("InstalledUICulture").OfType <IPropertySymbol>().FirstOrDefault();
var threadType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemThreadingThread);
var currentThreadCurrentUICultureProperty = threadType?.GetMembers("CurrentUICulture").OfType <IPropertySymbol>().FirstOrDefault();
var activatorType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemActivator);
var resourceManagerType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemResourcesResourceManager);
var computerInfoType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftVisualBasicDevicesComputerInfo);
var installedUICulturePropertyOfComputerInfoType = computerInfoType?.GetMembers("InstalledUICulture").OfType <IPropertySymbol>().FirstOrDefault();
var obsoleteAttributeType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemObsoleteAttribute);
#endregion
context.RegisterOperationAction(oaContext =>
{
var invocationExpression = (IInvocationOperation)oaContext.Operation;
var targetMethod = invocationExpression.TargetMethod;
#region "Exceptions"
if (targetMethod.IsGenericMethod ||
targetMethod.ContainingType.IsErrorType() ||
(activatorType != null && activatorType.Equals(targetMethod.ContainingType)) ||
(resourceManagerType != null && resourceManagerType.Equals(targetMethod.ContainingType)) ||
IsValidToStringCall(invocationExpression, invariantToStringTypes, dateTimeType, dateTimeOffsetType, timeSpanType))
{
return;
}
#endregion
#region "IFormatProviderAlternateStringRule Only"
if (stringFormatMemberWithIFormatProviderStringAndParamsObjectParameter != null &&
!oaContext.Options.IsConfiguredToSkipAnalysis(IFormatProviderAlternateStringRule, targetMethod, oaContext.ContainingSymbol, oaContext.Compilation) &&
(targetMethod.Equals(stringFormatMemberWithStringAndObjectParameter) ||
targetMethod.Equals(stringFormatMemberWithStringObjectAndObjectParameter) ||
targetMethod.Equals(stringFormatMemberWithStringObjectObjectAndObjectParameter) ||
targetMethod.Equals(stringFormatMemberWithStringAndParamsObjectParameter)))
{
// Sample message for IFormatProviderAlternateStringRule: Because the behavior of string.Format(string, object) could vary based on the current user's locale settings,
// replace this call in IFormatProviderStringTest.M() with a call to string.Format(IFormatProvider, string, params object[]).
oaContext.ReportDiagnostic(
invocationExpression.Syntax.CreateDiagnostic(
IFormatProviderAlternateStringRule,
targetMethod.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat),
oaContext.ContainingSymbol.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat),
stringFormatMemberWithIFormatProviderStringAndParamsObjectParameter.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat)));
return;
}
#endregion
#region "IFormatProviderAlternateStringRule & IFormatProviderAlternateRule"
var iformatProviderAlternateRule = targetMethod.ReturnType.Equals(stringType) ?
IFormatProviderAlternateStringRule :
IFormatProviderAlternateRule;
if (!oaContext.Options.IsConfiguredToSkipAnalysis(iformatProviderAlternateRule, targetMethod, oaContext.ContainingSymbol, oaContext.Compilation))
{
IEnumerable <IMethodSymbol> methodsWithSameNameAsTargetMethod = targetMethod.ContainingType.GetMembers(targetMethod.Name).OfType <IMethodSymbol>().WhereMethodDoesNotContainAttribute(obsoleteAttributeType);
if (methodsWithSameNameAsTargetMethod.HasMoreThan(1))
{
var correctOverloads = methodsWithSameNameAsTargetMethod.GetMethodOverloadsWithDesiredParameterAtLeadingOrTrailing(targetMethod, iformatProviderType);
// If there are two matching overloads, one with CultureInfo as the first parameter and one with CultureInfo as the last parameter,
// report the diagnostic on the overload with CultureInfo as the last parameter, to match the behavior of FxCop.
var correctOverload = correctOverloads.FirstOrDefault(overload => overload.Parameters.Last().Type.Equals(iformatProviderType)) ?? correctOverloads.FirstOrDefault();
// Sample message for IFormatProviderAlternateRule: Because the behavior of Convert.ToInt64(string) could vary based on the current user's locale settings,
// replace this call in IFormatProviderStringTest.TestMethod() with a call to Convert.ToInt64(string, IFormatProvider).
if (correctOverload != null)
{
oaContext.ReportDiagnostic(
invocationExpression.Syntax.CreateDiagnostic(
iformatProviderAlternateRule,
targetMethod.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat),
oaContext.ContainingSymbol.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat),
correctOverload.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat)));
}
}
}
#endregion
#region "UICultureStringRule & UICultureRule"
var uiCultureRule = targetMethod.ReturnType.Equals(stringType) ?
UICultureStringRule :
UICultureRule;
if (!oaContext.Options.IsConfiguredToSkipAnalysis(uiCultureRule, targetMethod, oaContext.ContainingSymbol, oaContext.Compilation))
{
IEnumerable <int> IformatProviderParameterIndices = GetIndexesOfParameterType(targetMethod, iformatProviderType);
foreach (var index in IformatProviderParameterIndices)
{
var argument = invocationExpression.Arguments[index];
if (argument != null && currentUICultureProperty != null &&
installedUICultureProperty != null && currentThreadCurrentUICultureProperty != null)
{
var semanticModel = argument.SemanticModel;
var symbol = semanticModel.GetSymbolInfo(argument.Value.Syntax, oaContext.CancellationToken).Symbol;
if (symbol != null &&
(symbol.Equals(currentUICultureProperty) ||
symbol.Equals(installedUICultureProperty) ||
symbol.Equals(currentThreadCurrentUICultureProperty) ||
(installedUICulturePropertyOfComputerInfoType != null && symbol.Equals(installedUICulturePropertyOfComputerInfoType))))
{
// Sample message
// 1. UICultureStringRule - 'TestClass.TestMethod()' passes 'Thread.CurrentUICulture' as the 'IFormatProvider' parameter to 'TestClass.CalleeMethod(string, IFormatProvider)'.
// This property returns a culture that is inappropriate for formatting methods.
// 2. UICultureRule -'TestClass.TestMethod()' passes 'CultureInfo.CurrentUICulture' as the 'IFormatProvider' parameter to 'TestClass.Callee(IFormatProvider, string)'.
// This property returns a culture that is inappropriate for formatting methods.
oaContext.ReportDiagnostic(
invocationExpression.Syntax.CreateDiagnostic(
uiCultureRule,
oaContext.ContainingSymbol.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat),
symbol.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat),
targetMethod.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat)));
}
}
}
}
#endregion
}, OperationKind.Invocation);
}
#pragma warning disable RS1012 // Start action has no registered actions.
public static SyntaxTree GetFirstSyntaxTree(this CompilationStartAnalysisContext context) =>
#pragma warning restore RS1012 // Start action has no registered actions.
context.Compilation.SyntaxTrees.FirstOrDefault();
private static bool ShouldAnalyze(CompilationStartAnalysisContext context, GeneratedCodeRecognizer generatedCodeRecognizer, SyntaxTree syntaxTree, Compilation c, AnalyzerOptions options) => SonarAnalysisContext.ShouldAnalyzeGenerated(context, c, options) || !syntaxTree.IsGenerated(generatedCodeRecognizer, c);
private void AnalyzeCompilationSymbol(CompilationStartAnalysisContext context)
{
var exceptionType = context.Compilation.GetTypeByMetadataName(WellKnownTypeNames.SystemException);
if (exceptionType == null)
{
return;
}
// Analyze named types
context.RegisterSymbolAction(symbolContext =>
{
var namedTypeSymbol = (INamedTypeSymbol)symbolContext.Symbol;
//Check if type derives from Exception type
if (namedTypeSymbol.DerivesFrom(exceptionType))
{
//Set flags for the 3 different constructos, that is being searched for
var defaultConstructorFound = false; //flag for default constructor
var secondConstructorFound = false; //flag for constructor with string type parameter
var thirdConstructorFound = false; //flag for constructor with string and exception type parameter
foreach (IMethodSymbol ctor in namedTypeSymbol.Constructors)
{
var parameters = ctor.GetParameters();
//case 1: Default constructor - no parameters
if (parameters.Length == 0)
{
defaultConstructorFound = true;
}
//case 2: Constructor with string type parameter
else if (parameters.Length == 1 && parameters[0].Type.SpecialType == SpecialType.System_String)
{
secondConstructorFound = true;
}
//case 3: Constructor with string type and exception type parameter
else if (parameters.Length == 2 && parameters[0].Type.SpecialType == SpecialType.System_String &&
parameters[1].Type.Equals(exceptionType))
{
thirdConstructorFound = true;
}
if (defaultConstructorFound && secondConstructorFound && thirdConstructorFound)
{
//reaches here only when all 3 constructors are found - no diagnostic needed
return;
}
} //end of for loop
if (!defaultConstructorFound) //missing default constructor
{
ReportDiagnostic(symbolContext, namedTypeSymbol, MissingCtorSignature.CtorWithNoParameter, GetConstructorSignatureNoParameter(namedTypeSymbol));
}
if (!secondConstructorFound) //missing constructor with string parameter
{
ReportDiagnostic(symbolContext, namedTypeSymbol, MissingCtorSignature.CtorWithStringParameter, GetConstructorSignatureStringTypeParameter(namedTypeSymbol));
}
if (!thirdConstructorFound) //missing constructor with string and exception type parameter - report diagnostic
{
ReportDiagnostic(symbolContext, namedTypeSymbol, MissingCtorSignature.CtorWithStringAndExceptionParameters, GetConstructorSignatureStringAndExceptionTypeParameter(namedTypeSymbol));
}
}
}, SymbolKind.NamedType);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleIdentifierNameSyntax, SyntaxKind.IdentifierName);
}
private void OnCompilationStartAction(CompilationStartAnalysisContext context, Configuration config)
{
context.RegisterSyntaxNodeAction(VisitSyntaxNode, VB.SyntaxKind.IdentifierName);
}
protected override DiagnosticAnalyzerSymbolAnalyzer GetDiagnosticAnalyzerSymbolAnalyzer(CompilationStartAnalysisContext compilationContext, INamedTypeSymbol diagnosticAnalyzer, INamedTypeSymbol diagnosticAnalyzerAttribute)
{
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
return(new AttributeAnalyzer(diagnosticAnalyzer, diagnosticAnalyzerAttribute, attributeUsageAttribute));
}
#pragma warning disable RS1012
internal static bool IsAnalyzerSuppressed(this CompilationStartAnalysisContext context, DiagnosticDescriptor descriptor)
{
return(context.Compilation.IsAnalyzerSuppressed(descriptor));
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxTreeActionHonorExclusions(HandleSyntaxTree);
}
internal override void AnalyzeCompilation(CompilationStartAnalysisContext compilationStartContext, PXContext pxContext)
{
compilationStartContext.RegisterSymbolAction(c => AnalyzeMethod(c, pxContext), SymbolKind.Method);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleXmlElement, SyntaxKind.XmlElement);
context.RegisterSyntaxNodeActionHonorExclusions(HandleXmlEmptyElement, SyntaxKind.XmlEmptyElement);
}
internal override void AnalyzeCompilation(CompilationStartAnalysisContext compilationStartContext, PXContext pxContext)
{
compilationStartContext.RegisterSyntaxNodeAction(syntaxContext =>
AnalyzePXGraphViews(syntaxContext, pxContext), SyntaxKind.ClassDeclaration);
}
public override void OnCompilationStart(CompilationStartAnalysisContext obj)
{
_allowedPinvokeFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).IndexOf("PinvokeAnalyzer_", StringComparison.OrdinalIgnoreCase) >= 0);
_exceptionFile = obj.Options.AdditionalFiles.FirstOrDefault(f => Path.GetFileName(f.Path).IndexOf("PinvokeAnalyzerExceptionList.analyzerdata", StringComparison.OrdinalIgnoreCase) >= 0);
obj.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);
}
protected abstract void RegisterIdentifierAnalysis(CompilationStartAnalysisContext context);
protected override DiagnosticAnalyzerSymbolAnalyzer GetDiagnosticAnalyzerSymbolAnalyzer(CompilationStartAnalysisContext compilationContext, INamedTypeSymbol diagnosticAnalyzer, INamedTypeSymbol diagnosticAnalyzerAttribute)
{
Compilation compilation = compilationContext.Compilation;
INamedTypeSymbol compilationType = compilation.GetTypeByMetadataName(s_compilationTypeFullName);
if (compilationType == null)
{
return(null);
}
INamedTypeSymbol symbolType = compilation.GetTypeByMetadataName(s_symbolTypeFullName);
if (symbolType == null)
{
return(null);
}
INamedTypeSymbol operationType = compilation.GetTypeByMetadataName(s_operationTypeFullName);
if (operationType == null)
{
return(null);
}
return(new FieldsAnalyzer(compilationType, symbolType, operationType, diagnosticAnalyzer, diagnosticAnalyzerAttribute));
}
protected override void GetCodeBlockStartedAnalyzer(CompilationStartAnalysisContext context, INamedTypeSymbol genericEnumerableSymbol, IMethodSymbol genericEmptyEnumerableSymbol)
{
context.RegisterCodeBlockStartAction <SyntaxKind>(new CodeBlockStartedAnalyzer(genericEnumerableSymbol, genericEmptyEnumerableSymbol).Initialize);
}
protected abstract AbstractAnalyzer GetAnalyzer(CompilationStartAnalysisContext context, INamedTypeSymbol disposableType);
protected override DiagnosticAnalyzerSymbolAnalyzer?GetDiagnosticAnalyzerSymbolAnalyzer(CompilationStartAnalysisContext compilationContext, INamedTypeSymbol diagnosticAnalyzer, INamedTypeSymbol diagnosticAnalyzerAttribute)
{
Compilation compilation = compilationContext.Compilation;
INamedTypeSymbol?compilationEndAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsCompilationEndAnalysisContext);
if (compilationEndAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?codeBlockAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsCodeBlockAnalysisContext);
if (codeBlockAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?operationBlockAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsOperationBlockAnalysisContext);
if (operationBlockAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?operationAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsOperationAnalysisContext);
if (operationAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?semanticModelAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsSemanticModelAnalysisContext);
if (semanticModelAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?symbolAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsSymbolAnalysisContext);
if (symbolAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?syntaxNodeAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsSyntaxNodeAnalysisContext);
if (syntaxNodeAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?syntaxTreeAnalysisContext = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsSyntaxTreeAnalysisContext);
if (syntaxTreeAnalysisContext == null)
{
return(null);
}
INamedTypeSymbol?diagnosticType = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnostic);
if (diagnosticType == null)
{
return(null);
}
INamedTypeSymbol?diagnosticDescriptorType = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticDescriptor);
if (diagnosticDescriptorType == null)
{
return(null);
}
ImmutableHashSet <INamedTypeSymbol> contextTypes = ImmutableHashSet.Create(compilationEndAnalysisContext, codeBlockAnalysisContext,
operationBlockAnalysisContext, operationAnalysisContext, semanticModelAnalysisContext, symbolAnalysisContext, syntaxNodeAnalysisContext, syntaxTreeAnalysisContext);
return(GetAnalyzer(contextTypes, diagnosticType, diagnosticDescriptorType, diagnosticAnalyzer, diagnosticAnalyzerAttribute));
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
}
protected override DiagnosticAnalyzerSymbolAnalyzer?GetDiagnosticAnalyzerSymbolAnalyzer(CompilationStartAnalysisContext compilationContext, INamedTypeSymbol diagnosticAnalyzer, INamedTypeSymbol diagnosticAnalyzerAttribute)
{
var compilation = compilationContext.Compilation;
var analysisContext = compilation.GetOrCreateTypeByMetadataName(AnalysisContextFullName);
if (analysisContext is null)
{
return(null);
}
compilationContext.RegisterOperationBlockStartAction(context =>
{
if (context.OwningSymbol?.Kind != SymbolKind.Method)
{
return;
}
var method = (IMethodSymbol)context.OwningSymbol;
if (method.Name != nameof(DiagnosticAnalyzer.Initialize))
{
return;
}
IParameterSymbol?analysisContextParameter = null;
foreach (var parameter in method.Parameters)
{
if (!Equals(parameter.Type, analysisContext))
{
continue;
}
analysisContextParameter = parameter;
break;
}
if (analysisContextParameter is null)
{
return;
}
var analyzer = new EnableConcurrentExecutionOperationAnalyzer(analysisContextParameter);
context.RegisterOperationAction(analyzer.HandleInvocationOperation, OperationKind.Invocation);
context.RegisterOperationBlockEndAction(analyzer.HandleOperationBlockEnd);
});
// This analyzer only performs operation block analysis
return(null);
}
internal static bool AreAnalyzersSuppressed(this CompilationStartAnalysisContext context, ImmutableArray <DiagnosticDescriptor> descriptors)
{
return(context.Compilation.AreAnalyzersSuppressed(descriptors));
}
private static void CheckVisibility(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeAction(checkVisibility, ImmutableArray.Create(s_typeDeclarations));
context.RegisterSyntaxNodeAction(checkMemberVisibility, ImmutableArray.Create(s_memberDeclarations));
}
/// <summary>
/// Called once at session start to register actions in the analysis context.
/// </summary>
protected override void Initialize(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.SimpleMemberAccessExpression);
}
internal override void AnalyzeSyntaxNode(CompilationStartAnalysisContext context, SyntaxNode catchClauseSyntaxNode)
{
}
public void Initialize(CompilationStartAnalysisContext context)
{
context.RegisterSymbolAction(AnalyzeNamedTypeSymbol, SymbolKind.NamedType);
context.RegisterOperationBlockAction(AnalyzeOperationBlock);
}
private static void HandleCompilationStart(CompilationStartAnalysisContext context)
{
context.RegisterSyntaxNodeActionHonorExclusions(ThisExpressionAction, SyntaxKind.ThisExpression);
}
public static void RegisterSyntaxNodeActionInNonGenerated <TLanguageKindEnum>(this CompilationStartAnalysisContext context,
GeneratedCodeRecognizer generatedCodeRecognizer,
Action <SyntaxNodeAnalysisContext> action,
params TLanguageKindEnum[] syntaxKinds) where TLanguageKindEnum : struct =>
context.RegisterSyntaxNodeAction(c =>
{
if (ShouldAnalyze(context, generatedCodeRecognizer, c.GetSyntaxTree(), c.Compilation, c.Options))
{
action(c);
}
}, syntaxKinds);
internal static bool AreAnalyzersSuppressed(this CompilationStartAnalysisContext context, DiagnosticDescriptor descriptor1, DiagnosticDescriptor descriptor2, DiagnosticDescriptor descriptor3)
{
return(context.Compilation.AreAnalyzersSuppressed(descriptor1, descriptor2, descriptor3));
}
internal override void AnalyzeCompilation(CompilationStartAnalysisContext compilationStartContext, PXContext pxContext)
{
compilationStartContext.RegisterSymbolAction(c => AnalyzeSymbolHandleAggregateException(c, pxContext), SymbolKind);
// TODO: Enable this operation action after migration to Roslyn v2
//compilationStartContext.RegisterOperationAction(c => AnalyzeLambda(c, pxContext, codeAnalysisSettings), OperationKind.LambdaExpression);
}
