public override void Initialize(AnalysisContext analysisContext) { analysisContext.EnableConcurrentExecution(); analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterCompilationAction(AnalyzeCompilation); }
/// <inheritdoc/> public override void Initialize(AnalysisContext context) { context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.EnableConcurrentExecution(); context.RegisterSyntaxTreeAction(SyntaxTreeAction); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction( c => { var assignmentNode = (AssignmentExpressionSyntax)c.Node; var symbol = c.SemanticModel.GetSymbolInfo(assignmentNode.Left).Symbol; if (symbol != null && (AssignsToParameter(symbol) || AssignsToCatchVariable(symbol))) { c.ReportDiagnostic(Diagnostic.Create(Rule, assignmentNode.Left.GetLocation(), assignmentNode.Left.ToString())); } }, SyntaxKind.SimpleAssignmentExpression, SyntaxKind.AddAssignmentExpression, SyntaxKind.SubtractAssignmentExpression, SyntaxKind.MultiplyAssignmentExpression, SyntaxKind.DivideAssignmentExpression, SyntaxKind.ModuloAssignmentExpression, SyntaxKind.AndAssignmentExpression, SyntaxKind.ExclusiveOrAssignmentExpression, SyntaxKind.OrAssignmentExpression, SyntaxKind.LeftShiftAssignmentExpression, SyntaxKind.RightShiftAssignmentExpression); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction((syntaxContext) => { syntaxContext.ReportDiagnostic(Diagnostic.Create(Rule, syntaxContext.Node.GetLocation())); }, SyntaxKind.ParamsKeyword); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction( (nodeContext) => { Diagnostic diagnostic; if (TryGetDiagnostic(nodeContext, out diagnostic)) { nodeContext.ReportDiagnostic(diagnostic); } }, new SyntaxKind[] { SyntaxKind.MethodDeclaration, SyntaxKind.FieldDeclaration, SyntaxKind.PropertyDeclaration, SyntaxKind.IndexerDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.OperatorDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.EnumDeclaration, SyntaxKind.DelegateDeclaration } ); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var outerInvocation = (InvocationExpressionSyntax)c.Node; if (!IsMethodOrderByExtension(outerInvocation, c.SemanticModel)) { return; } var memberAccess = outerInvocation.Expression as MemberAccessExpressionSyntax; if (memberAccess == null) { return; } var innerInvocation = memberAccess.Expression as InvocationExpressionSyntax; if (!IsMethodOrderByExtension(innerInvocation, c.SemanticModel) && !IsMethodThenByExtension(innerInvocation, c.SemanticModel)) { return; } c.ReportDiagnostic(Diagnostic.Create(Rule, memberAccess.Name.GetLocation())); }, SyntaxKind.InvocationExpression); }
public override void Initialize(AnalysisContext context) { Arg.IsNotNull(() => context); // TODO: Consider registering other actions that act on syntax instead of or in addition to symbols context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.NamedType); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => c.ReportDiagnostic(Diagnostic.Create(Rule, c.Node.GetLocation())), SyntaxKind.ExitForStatement, SyntaxKind.ExitFunctionStatement, SyntaxKind.ExitPropertyStatement, SyntaxKind.ExitSubStatement, SyntaxKind.ExitTryStatement, SyntaxKind.ExitWhileStatement); context.RegisterSyntaxNodeActionInNonGenerated( c => { var parent = c.Node.Parent; while(parent != null && !(parent is DoLoopBlockSyntax)) { parent = parent.Parent; } if (parent == null || parent.IsKind(SyntaxKind.SimpleDoLoopBlock)) { return; } c.ReportDiagnostic(Diagnostic.Create(Rule, c.Node.GetLocation())); }, SyntaxKind.ExitDoStatement); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { if (c.SemanticModel.Compilation.IsTest() || c.SemanticModel.Compilation.Options.OutputKind != OutputKind.DynamicallyLinkedLibrary) { //this rule only makes sense in libraries return; } var awaitExpression = (AwaitExpressionSyntax)c.Node; var expression = awaitExpression.Expression; if (expression == null) { return; } var taskType = c.SemanticModel.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task"); if (taskType == null) { return; } var type = c.SemanticModel.GetTypeInfo(expression).Type; if (type != null && taskType.Equals(type)) { c.ReportDiagnostic(Diagnostic.Create(Rule, expression.GetLocation())); } }, SyntaxKind.AwaitExpression); }
/// <inheritdoc/> public override void Initialize(AnalysisContext context) { context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.EnableConcurrentExecution(); context.RegisterSyntaxNodeAction(DoStatementAction, SyntaxKind.DoStatement); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var methodCall = (InvocationExpressionSyntax) c.Node; var methodParameterLookup = new MethodParameterLookup(methodCall, c.SemanticModel); var argumentMappings = methodCall.ArgumentList.Arguments.Select(argument => new ArgumentParameterMapping(argument, methodParameterLookup.GetParameterSymbol(argument))) .ToList(); var methodSymbol = methodParameterLookup.MethodSymbol; if (methodSymbol == null) { return; } foreach (var argumentMapping in argumentMappings) { if (ArgumentHasDefaultValue(argumentMapping, c.SemanticModel)) { var argument = argumentMapping.Argument; var parameter = argumentMapping.Parameter; c.ReportDiagnostic(Diagnostic.Create(Rule, argument.GetLocation(), parameter.Name)); } } }, SyntaxKind.InvocationExpression); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.EnableConcurrentExecution(); analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); analysisContext.RegisterSymbolAction( symbolAnalysisContext => { ISymbol symbol = symbolAnalysisContext.Symbol; if (!symbol.ContainingType.IsGenericType || symbol.DeclaredAccessibility != Accessibility.Public || !symbol.IsStatic) { return; } var methodSymbol = symbol as IMethodSymbol; if (methodSymbol != null && (methodSymbol.IsAccessorMethod() || (methodSymbol.MethodKind == MethodKind.UserDefinedOperator && (methodSymbol.Name == WellKnownMemberNames.EqualityOperatorName || methodSymbol.Name == WellKnownMemberNames.InequalityOperatorName)))) { return; } symbolAnalysisContext.ReportDiagnostic(symbol.CreateDiagnostic(Rule, symbol.Name)); }, SymbolKind.Method, SymbolKind.Property); }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterCompilationStartAction(compilationContext => { var exportAttribute = compilationContext.Compilation.GetTypeByMetadataName("System.Composition.ExportAttribute"); if (exportAttribute == null) { // We don't need to check assemblies unless they're referencing both MEFv2, so we're done return; } compilationContext.RegisterSymbolAction(symbolContext => { var namedType = (INamedTypeSymbol)symbolContext.Symbol; var namedTypeAttributes = namedType.GetApplicableAttributes(); var exportAttributeApplication = namedTypeAttributes.FirstOrDefault(ad => ad.AttributeClass.DerivesFrom(exportAttribute)); if (exportAttributeApplication != null) { if (!namedTypeAttributes.Any(ad => ad.AttributeClass.Name == "SharedAttribute" && ad.AttributeClass.ContainingNamespace.Equals(exportAttribute.ContainingNamespace))) { // '{0}' is exported with MEFv2 and hence must be marked as Shared symbolContext.ReportDiagnostic(Diagnostic.Create(Rule, exportAttributeApplication.ApplicationSyntaxReference.GetSyntax().GetLocation(), namedType.Name)); } } }, SymbolKind.NamedType); }); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var assignment = (AssignmentExpressionSyntax)c.Node; if (!IsDelegateSubtraction(assignment, c.SemanticModel) || ExpressionIsSimple(assignment.Right)) { return; } c.ReportDiagnostic(Diagnostic.Create(Rule, assignment.GetLocation())); }, SyntaxKind.SubtractAssignmentExpression); context.RegisterSyntaxNodeAction( c => { var binary = (BinaryExpressionSyntax)c.Node; if (!IsDelegateSubtraction(binary, c.SemanticModel) || !IsTopLevelSubtraction(binary)) { return; } if (!BinaryIsValidSubstraction(binary)) { c.ReportDiagnostic(Diagnostic.Create(Rule, binary.GetLocation())); } }, SyntaxKind.SubtractExpression); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.RegisterOperationAction(saContext => { var fieldInitializer = saContext.Operation as IFieldInitializer; // Diagnostics are reported on the last initialized field to retain the previous FxCop behavior var lastField = fieldInitializer.InitializedFields.LastOrDefault(); var fieldInitializerValue = fieldInitializer.Value; if (fieldInitializerValue == null|| lastField.IsConst || lastField.GetResultantVisibility() == SymbolVisibility.Public ||!lastField.IsStatic || !lastField.IsReadOnly || !fieldInitializerValue.ConstantValue.HasValue) { return; } var initializerValue = fieldInitializerValue.ConstantValue.Value; // Though null is const we dont fire the diagnostic to be FxCop Compact if (initializerValue != null) { if (fieldInitializerValue.Type == saContext.Compilation.GetSpecialType(SpecialType.System_String) && ((string)initializerValue)?.Length == 0) { saContext.ReportDiagnostic(lastField.CreateDiagnostic(EmptyStringRule, lastField.Name)); return; } saContext.ReportDiagnostic(lastField.CreateDiagnostic(DefaultRule, lastField.Name, initializerValue)); } }, OperationKind.FieldInitializerAtDeclaration); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var expression = (BinaryExpressionSyntax) c.Node; var parenthesizedParent = expression.Parent; while (parenthesizedParent is ParenthesizedExpressionSyntax) { parenthesizedParent = parenthesizedParent.Parent; } var logicalNot = parenthesizedParent as PrefixUnaryExpressionSyntax; if (logicalNot != null && logicalNot.OperatorToken.IsKind(SyntaxKind.ExclamationToken)) { c.ReportDiagnostic(Diagnostic.Create(Rule, logicalNot.GetLocation(), OppositeTokens[expression.OperatorToken.Kind()])); } }, SyntaxKind.GreaterThanExpression, SyntaxKind.GreaterThanOrEqualExpression, SyntaxKind.LessThanExpression, SyntaxKind.LessThanOrEqualExpression, SyntaxKind.EqualsExpression, SyntaxKind.NotEqualsExpression); }
public override void Initialize(AnalysisContext context) { context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterSyntaxNodeAction( (nodeContext) => { Diagnostic diagnostic; if (TryGetDiagnostic(nodeContext, out diagnostic)) { nodeContext.ReportDiagnostic(diagnostic); } }, new SyntaxKind[] { SyntaxKind.LocalDeclarationStatement } ); context.RegisterSyntaxNodeAction( (nodeContext) => { Diagnostic diagnostic; if (TryGetDiagnosticFromForeach(nodeContext, out diagnostic)) { nodeContext.ReportDiagnostic(diagnostic); } }, new SyntaxKind[] { SyntaxKind.ForEachStatement } ); }
/// <inheritdoc/> public override void Initialize(AnalysisContext context) { context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.EnableConcurrentExecution(); context.RegisterSyntaxNodeAction(RegionDirectiveTriviaAction, SyntaxKind.RegionDirectiveTrivia); }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterCompilationStartAction(OnCompilationStart); }
public override void Initialize(AnalysisContext context) { context.RegisterNodaTimeSyntaxNodeAction(PublicMethodParametersShouldNotBeTrusted, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration); context.RegisterNodaTimeSyntaxNodeAction(FirstUseOfUntrustedParameterShouldNotBeArgumentToTrustedParameter, SyntaxKind.Parameter); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.RegisterCompilationStartAction( (context) => { INamedTypeSymbol dllImportType = context.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.DllImportAttribute"); if (dllImportType == null) { return; } INamedTypeSymbol marshalAsType = context.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.MarshalAsAttribute"); if (marshalAsType == null) { return; } INamedTypeSymbol stringBuilderType = context.Compilation.GetTypeByMetadataName("System.Text.StringBuilder"); if (stringBuilderType == null) { return; } INamedTypeSymbol unmanagedType = context.Compilation.GetTypeByMetadataName("System.Runtime.InteropServices.UnmanagedType"); if (unmanagedType == null) { return; } context.RegisterSymbolAction(new Analyzer(dllImportType, marshalAsType, stringBuilderType, unmanagedType).AnalyzeSymbol, SymbolKind.Method); }); }
public override void Initialize(AnalysisContext context) { context.RegisterCodeBlockStartActionInNonGenerated<SyntaxKind>( cbc => { var methodDeclaration = cbc.CodeBlock as MethodDeclarationSyntax; if (methodDeclaration == null || methodDeclaration.Identifier.Text != "ToString") { return; } cbc.RegisterSyntaxNodeAction(c => { var returnStatement = (ReturnStatementSyntax)c.Node; var nullExpression = returnStatement.Expression as LiteralExpressionSyntax; if (nullExpression != null && nullExpression.IsKind(SyntaxKind.NullLiteralExpression)) { c.ReportDiagnostic(Diagnostic.Create(Rule, returnStatement.GetLocation())); } }, SyntaxKind.ReturnStatement); }); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var field = (FieldDeclarationSyntax)c.Node; foreach (var variable in field.Declaration.Variables .Where(v => v.Initializer != null)) { var variableSymbol = c.SemanticModel.GetDeclaredSymbol(variable) as IFieldSymbol; if (variableSymbol == null || variableSymbol.IsConst) { continue; } if (CheckDefaultExpressionInitializer(variable) || CheckReferenceTypeNullInitializer(variable, variableSymbol) || CheckValueTypeDefaultValueInitializer(variable, variableSymbol)) { c.ReportDiagnostic(Diagnostic.Create(Rule, variable.Initializer.GetLocation(), variableSymbol.Name)); return; } } }, SyntaxKind.FieldDeclaration); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var lessThan = (BinaryExpressionSyntax) c.Node; int constValue; if (SillyBitwiseOperation.TryGetConstantIntValue(lessThan.Left, out constValue) && constValue == 0 && IsIndexOfCall(lessThan.Right, c.SemanticModel)) { c.ReportDiagnostic(Diagnostic.Create(Rule, Location.Create(lessThan.SyntaxTree, TextSpan.FromBounds(lessThan.Left.SpanStart, lessThan.OperatorToken.Span.End)))); } }, SyntaxKind.LessThanExpression); context.RegisterSyntaxNodeActionInNonGenerated( c => { var greaterThan = (BinaryExpressionSyntax)c.Node; int constValue; if (SillyBitwiseOperation.TryGetConstantIntValue(greaterThan.Right, out constValue) && constValue == 0 && IsIndexOfCall(greaterThan.Left, c.SemanticModel)) { c.ReportDiagnostic(Diagnostic.Create(Rule, Location.Create(greaterThan.SyntaxTree, TextSpan.FromBounds(greaterThan.OperatorToken.SpanStart, greaterThan.Right.Span.End)))); } }, SyntaxKind.GreaterThanExpression); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var assignment = (AssignmentExpressionSyntax) c.Node; if (IsInSubExpression(assignment) || IsInCondition(assignment)) { c.ReportDiagnostic(Diagnostic.Create(Rule, assignment.OperatorToken.GetLocation(), assignment.Left.ToString())); } }, SyntaxKind.SimpleAssignmentExpression, SyntaxKind.AddAssignmentExpression, SyntaxKind.SubtractAssignmentExpression, SyntaxKind.MultiplyAssignmentExpression, SyntaxKind.DivideAssignmentExpression, SyntaxKind.ModuloAssignmentExpression, SyntaxKind.AndAssignmentExpression, SyntaxKind.ExclusiveOrAssignmentExpression, SyntaxKind.OrAssignmentExpression, SyntaxKind.LeftShiftAssignmentExpression, SyntaxKind.RightShiftAssignmentExpression); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction( AnalyzeInvocation, new SyntaxKind[] { SyntaxKind.InvocationExpression } ); }
public override void Initialize(AnalysisContext context) { context.RegisterCodeBlockStartAction<SyntaxKind>(startCodeBlockContext => { // We only care about method bodies. if (startCodeBlockContext.OwningSymbol.Kind != SymbolKind.Method) { return; } // We only care about methods with parameters. var method = (IMethodSymbol)startCodeBlockContext.OwningSymbol; if (method.Parameters.IsEmpty) { return; } // Initialize local mutable state in the start action. var analyzer = new UnusedParametersAnalyzer(method); // Register an intermediate non-end action that accesses and modifies the state. startCodeBlockContext.RegisterSyntaxNodeAction(analyzer.AnalyzeSyntaxNode, SyntaxKind.IdentifierName); // Register an end action to report diagnostics based on the final state. startCodeBlockContext.RegisterCodeBlockEndAction(analyzer.CodeBlockEndAction); }); }
public override void Initialize(AnalysisContext context) { context.RegisterSymbolAction( c => { var symbol = c.Symbol as INamedTypeSymbol; if (symbol == null || !symbol.IsAbstract || symbol.TypeKind != TypeKind.Class) { return; } if (AbstractClassShouldBeInterface(symbol)) { ReportClass(symbol, MessageToInterface, c); return; } if (AbstractClassShouldBeConcreteClass(symbol)) { ReportClass(symbol, MessageToConcreteClass, c); return; } }, SymbolKind.NamedType); }
/// <inheritdoc/> public override void Initialize(AnalysisContext context) { context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.EnableConcurrentExecution(); context.RegisterSyntaxNodeAction(DocumentationTriviaAction, SyntaxKind.SingleLineDocumentationCommentTrivia); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.RegisterCompilationStartAction(compilationContext => { INamedTypeSymbol conditionalAttributeSymbol = WellKnownTypes.ConditionalAttribute(compilationContext.Compilation); compilationContext.RegisterOperationBlockAction(context => { var method = context.OwningSymbol as IMethodSymbol; if (method == null) { return; } if (!method.IsFinalizer()) { return; } if (IsEmptyFinalizer(context.OperationBlocks, conditionalAttributeSymbol)) { context.ReportDiagnostic(context.OwningSymbol.CreateDiagnostic(Rule)); } }); }); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeSyntaxNode, SyntaxKind.ElementAccessExpression); }
// ---------------- Functions ---------------- public static void Init(AnalysisContext context) { context.RegisterOperationAction(Run, OperationKind.Invocation); }
public override void Initialize(AnalysisContext context) #pragma warning restore RS1026 // Enable concurrent execution #pragma warning restore RS1025 // Configure generated code analysis { // This diagnostic is not implemented (by design) in StyleCopAnalyzers. }
public override void Initialize(AnalysisContext context) { context.RegisterSymbolAction( (symbolContext) => { }, SymbolKindsOfInterest); }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); // Security analyzer - analyze and report diagnostics on generated code. context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics); context.RegisterCompilationStartAction(compilationStartAnalysisContext => { var compilation = compilationStartAnalysisContext.Compilation; var wellKnownTypeProvider = WellKnownTypeProvider.GetOrCreate(compilation); if (!wellKnownTypeProvider.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeInteropServicesDllImportAttribute, out INamedTypeSymbol dllImportAttributeTypeSymbol) || !wellKnownTypeProvider.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeInteropServicesDefaultDllImportSearchPathsAttribute, out INamedTypeSymbol defaultDllImportSearchPathsAttributeTypeSymbol)) { return; } var cancellationToken = compilationStartAnalysisContext.CancellationToken; var unsafeDllImportSearchPathBits = compilationStartAnalysisContext.Options.GetUnsignedIntegralOptionValue( optionName: EditorConfigOptionNames.UnsafeDllImportSearchPathBits, rule: DoNotUseUnsafeDllImportSearchPathRule, defaultValue: UnsafeBits, cancellationToken: cancellationToken); var defaultDllImportSearchPathsAttributeOnAssembly = compilation.Assembly.GetAttributes().FirstOrDefault(o => o.AttributeClass.Equals(defaultDllImportSearchPathsAttributeTypeSymbol)); compilationStartAnalysisContext.RegisterSymbolAction(symbolAnalysisContext => { var symbol = symbolAnalysisContext.Symbol; if (!symbol.IsExtern || !symbol.IsStatic) { return; } var dllImportAttribute = symbol.GetAttributes().FirstOrDefault(s => s.AttributeClass.Equals(dllImportAttributeTypeSymbol)); var defaultDllImportSearchPathsAttribute = symbol.GetAttributes().FirstOrDefault(s => s.AttributeClass.Equals(defaultDllImportSearchPathsAttributeTypeSymbol)); if (dllImportAttribute != null) { var constructorArguments = dllImportAttribute.ConstructorArguments; if (constructorArguments.Length == 0) { return; } if (Path.IsPathRooted(constructorArguments[0].Value.ToString())) { return; } var rule = UseDefaultDllImportSearchPathsAttributeRule; var ruleArgument = symbol.Name; var validatedDefaultDllImportSearchPathsAttribute = defaultDllImportSearchPathsAttribute ?? defaultDllImportSearchPathsAttributeOnAssembly; if (validatedDefaultDllImportSearchPathsAttribute != null) { var dllImportSearchPath = (int)validatedDefaultDllImportSearchPathsAttribute.ConstructorArguments.FirstOrDefault().Value; var validBits = dllImportSearchPath & unsafeDllImportSearchPathBits; if (dllImportSearchPath != LegacyBehavior && validBits == 0) { return; } rule = DoNotUseUnsafeDllImportSearchPathRule; ruleArgument = ((DllImportSearchPath)validBits).ToString(); } symbolAnalysisContext.ReportDiagnostic( symbol.CreateDiagnostic( rule, ruleArgument)); } }, SymbolKind.Method); }); }
public override void Initialize(AnalysisContext analysisContext) { }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeSymbol, SyntaxKind.InvocationExpression); }
protected override void RegisterIdentifierAnalysis(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeIdentifier, SyntaxKind.IdentifierName); }
/// <summary> /// Called once at session start to register actions in the analysis context. /// </summary> /// <param name="context"></param> public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeSymbol, SyntaxKind.MethodDeclaration); }
/// <inheritdoc/> public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeActionHonorExclusions(HandleCompilationUnit, SyntaxKind.CompilationUnit); context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclaration, SyntaxKind.NamespaceDeclaration); }
/// <inheritdoc/> public override void Initialize(AnalysisContext context) { context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.EnableConcurrentExecution(); context.RegisterSyntaxNodeAction(HandleInvocation, SyntaxKind.InvocationExpression); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeAttribute, SyntaxKind.Attribute); }
public override void Initialize(AnalysisContext context) { base.Initialize(context); context.RegisterSyntaxNodeAction(AnalyzeUsingStatement, SyntaxKind.UsingStatement); }
protected override void InitializeWorker(AnalysisContext context) { context.RegisterCompilationStartAction(compilationStartContext => { // State map for fields: // 'isCandidate' : Indicates whether the field is a candidate to be made readonly based on it's options. // 'written' : Indicates if there are any writes to the field outside the constructor and field initializer. var fieldStateMap = new ConcurrentDictionary <IFieldSymbol, (bool isCandidate, bool written)>(); // We register following actions in the compilation: // 1. A symbol action for field symbols to ensure the field state is initialized for every field in // the compilation. // 2. An operation action for field references to detect if a candidate field is written outside // constructor and field initializer, and update field state accordingly. // 3. A symbol start/end action for named types to report diagnostics for candidate fields that were // not written outside constructor and field initializer. compilationStartContext.RegisterSymbolAction(AnalyzeFieldSymbol, SymbolKind.Field); compilationStartContext.RegisterSymbolStartAction(symbolStartContext => { symbolStartContext.RegisterOperationAction(AnalyzeOperation, OperationKind.FieldReference); symbolStartContext.RegisterSymbolEndAction(OnSymbolEnd); }, SymbolKind.NamedType); return; // Local functions. void AnalyzeFieldSymbol(SymbolAnalysisContext symbolContext) { _ = TryGetOrInitializeFieldState((IFieldSymbol)symbolContext.Symbol, symbolContext.Options, symbolContext.CancellationToken); } void AnalyzeOperation(OperationAnalysisContext operationContext) { var fieldReference = (IFieldReferenceOperation)operationContext.Operation; (bool isCandidate, bool written) = TryGetOrInitializeFieldState(fieldReference.Field, operationContext.Options, operationContext.CancellationToken); // Ignore fields that are not candidates or have already been written outside the constructor/field initializer. if (!isCandidate || written) { return; } // Check if this is a field write outside constructor and field initializer, and update field state accordingly. if (IsFieldWrite(fieldReference, operationContext.ContainingSymbol)) { UpdateFieldStateOnWrite(fieldReference.Field); } } void OnSymbolEnd(SymbolAnalysisContext symbolEndContext) { // Report diagnostics for candidate fields that are not written outside constructor and field initializer. var members = ((INamedTypeSymbol)symbolEndContext.Symbol).GetMembers(); foreach (var member in members) { if (member is IFieldSymbol field && fieldStateMap.TryRemove(field, out var value)) { (bool isCandidate, bool written) = value; if (isCandidate && !written) { var option = GetCodeStyleOption(field, symbolEndContext.Options, symbolEndContext.CancellationToken); var diagnostic = DiagnosticHelper.Create( Descriptor, field.Locations[0], option.Notification.Severity, additionalLocations: null, properties: null); symbolEndContext.ReportDiagnostic(diagnostic); } } } } bool IsCandidateField(IFieldSymbol symbol) => symbol.DeclaredAccessibility == Accessibility.Private && !symbol.IsReadOnly && !symbol.IsConst && !symbol.IsImplicitlyDeclared && symbol.Locations.Length == 1 && symbol.Type.IsMutableValueType() == false && !symbol.IsFixedSizeBuffer; // Method to update the field state for a candidate field written outside constructor and field initializer. void UpdateFieldStateOnWrite(IFieldSymbol field) { Debug.Assert(IsCandidateField(field)); Debug.Assert(fieldStateMap.ContainsKey(field)); fieldStateMap[field] = (isCandidate: true, written: true); } // Method to get or initialize the field state. (bool isCandidate, bool written)TryGetOrInitializeFieldState(IFieldSymbol fieldSymbol, AnalyzerOptions options, CancellationToken cancellationToken) { if (!IsCandidateField(fieldSymbol)) { return(default);
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeSyntaxNode, SyntaxKind.VariableDeclarator); }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); // Security analyzer - analyze and report diagnostics on generated code. context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics); context.RegisterCompilationStartAction( (CompilationStartAnalysisContext compilationStartAnalysisContext) => { if (!compilationStartAnalysisContext.Compilation.TryGetOrCreateTypeByMetadataName( WellKnownTypeNames.SystemSecurityAuthenticationSslProtocols, out INamedTypeSymbol? sslProtocolsSymbol)) { return; } compilationStartAnalysisContext.RegisterOperationAction( (OperationAnalysisContext operationAnalysisContext) => { IFieldReferenceOperation fieldReferenceOperation = (IFieldReferenceOperation)operationAnalysisContext.Operation; if (IsReferencingSslProtocols( fieldReferenceOperation, out bool isDeprecatedProtocol, out bool isHardcodedOkayProtocol)) { if (isDeprecatedProtocol) { operationAnalysisContext.ReportDiagnostic( fieldReferenceOperation.CreateDiagnostic( DeprecatedRule, fieldReferenceOperation.Field.Name)); } else if (isHardcodedOkayProtocol) { operationAnalysisContext.ReportDiagnostic( fieldReferenceOperation.CreateDiagnostic( HardcodedRule, fieldReferenceOperation.Field.Name)); } } }, OperationKind.FieldReference); compilationStartAnalysisContext.RegisterOperationAction( (OperationAnalysisContext operationAnalysisContext) => { IOperation?valueOperation; switch (operationAnalysisContext.Operation) { case IAssignmentOperation assignmentOperation: // Make sure this is an assignment operation for a SslProtocols value. if (!sslProtocolsSymbol.Equals(assignmentOperation.Target.Type)) { return; } valueOperation = assignmentOperation.Value; break; case IArgumentOperation argumentOperation: if (!sslProtocolsSymbol.Equals(argumentOperation.Type)) { return; } valueOperation = argumentOperation.Value; break; case IReturnOperation returnOperation: if (returnOperation.ReturnedValue == null || !sslProtocolsSymbol.Equals(returnOperation.ReturnedValue.Type)) { return; } valueOperation = returnOperation.ReturnedValue; break; case IVariableInitializerOperation variableInitializerOperation: if (variableInitializerOperation.Value == null || !sslProtocolsSymbol.Equals(variableInitializerOperation.Value.Type)) { return; } valueOperation = variableInitializerOperation.Value; break; default: Debug.Fail("Unhandled IOperation " + operationAnalysisContext.Operation.Kind); return; } // Find the topmost operation with a bad bit set, unless we find an operation that would've been // flagged by the FieldReference callback above. IOperation?foundDeprecatedOperation = null; bool foundDeprecatedReference = false; IOperation?foundHardcodedOperation = null; bool foundHardcodedReference = false; foreach (IOperation childOperation in valueOperation.DescendantsAndSelf()) { if (childOperation is IFieldReferenceOperation fieldReferenceOperation && IsReferencingSslProtocols( fieldReferenceOperation, out var isDeprecatedProtocol, out var isHardcodedOkayProtocol)) { if (isDeprecatedProtocol) { foundDeprecatedReference = true; } else if (isHardcodedOkayProtocol) { foundHardcodedReference = true; } if (foundDeprecatedReference && foundHardcodedReference) { return; } } if (childOperation.ConstantValue.HasValue && childOperation.ConstantValue.Value is int integerValue) { if (foundDeprecatedOperation == null && // Only want the first. (integerValue & UnsafeBits) != 0) { foundDeprecatedOperation = childOperation; } if (foundHardcodedOperation == null && // Only want the first. (integerValue & HardcodedBits) != 0) { foundHardcodedOperation = childOperation; } } } if (foundDeprecatedOperation != null && !foundDeprecatedReference) { operationAnalysisContext.ReportDiagnostic( foundDeprecatedOperation.CreateDiagnostic( DeprecatedRule, foundDeprecatedOperation.ConstantValue)); } if (foundHardcodedOperation != null && !foundHardcodedReference) { operationAnalysisContext.ReportDiagnostic( foundHardcodedOperation.CreateDiagnostic( HardcodedRule, foundHardcodedOperation.ConstantValue)); } }, OperationKind.SimpleAssignment, OperationKind.CompoundAssignment, OperationKind.Argument, OperationKind.Return, OperationKind.VariableInitializer); return; // Local function(s). bool IsReferencingSslProtocols( IFieldReferenceOperation fieldReferenceOperation, out bool isDeprecatedProtocol, out bool isHardcodedOkayProtocol) { RoslynDebug.Assert(sslProtocolsSymbol != null); if (sslProtocolsSymbol.Equals(fieldReferenceOperation.Field.ContainingType)) { if (HardcodedSslProtocolsMetadataNames.Contains(fieldReferenceOperation.Field.Name)) { isHardcodedOkayProtocol = true; isDeprecatedProtocol = false; } else if (fieldReferenceOperation.Field.Name == "None") { isHardcodedOkayProtocol = false; isDeprecatedProtocol = false; } else { isDeprecatedProtocol = true; isHardcodedOkayProtocol = false; } return(true); } else { isHardcodedOkayProtocol = false; isDeprecatedProtocol = false; return(false); } } }); }
public override void Initialize(AnalysisContext context) { base.Initialize(context); context.RegisterSyntaxNodeAction(f => AnalyzeRegionDirectiveTrivia(f), SyntaxKind.RegionDirectiveTrivia); }
/// <summary> /// Initialize. /// </summary> /// <param name="context">The analysis context.</param> public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(CheckRegion, SyntaxKind.RegionDirectiveTrivia); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeSyntaxNode, SyntaxKind.LocalDeclarationStatement); }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterCompilationStartAction(compilationContext => { if (!DisposeAnalysisHelper.TryGetOrCreate(compilationContext.Compilation, out DisposeAnalysisHelper? disposeAnalysisHelper)) { return; } compilationContext.RegisterOperationBlockStartAction(operationBlockStartContext => { if (operationBlockStartContext.OwningSymbol is not IMethodSymbol containingMethod || containingMethod.OverriddenMethod == null || containingMethod.OverriddenMethod.IsAbstract) { return; } var disposeMethodKind = disposeAnalysisHelper.GetDisposeMethodKind(containingMethod); switch (disposeMethodKind) { case DisposeMethodKind.Dispose: case DisposeMethodKind.DisposeBool: case DisposeMethodKind.DisposeAsync: case DisposeMethodKind.DisposeCoreAsync: break; case DisposeMethodKind.Close: // FxCop compat: Ignore Close methods due to high false positive rate. return; default: return; } var invokesBaseDispose = false; operationBlockStartContext.RegisterOperationAction(operationContext => { if (invokesBaseDispose) { return; } var invocation = (IInvocationOperation)operationContext.Operation; if (Equals(invocation.TargetMethod, containingMethod.OverriddenMethod) && invocation.Instance is IInstanceReferenceOperation instanceReference && instanceReference.ReferenceKind == InstanceReferenceKind.ContainingTypeInstance) { Debug.Assert(disposeAnalysisHelper.GetDisposeMethodKind(invocation.TargetMethod) == disposeMethodKind); invokesBaseDispose = true; } }, OperationKind.Invocation); operationBlockStartContext.RegisterOperationBlockEndAction(operationEndContext => { if (!invokesBaseDispose) { // Ensure that method '{0}' calls '{1}' in all possible control flow paths. var arg1 = containingMethod.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat); var baseKeyword = containingMethod.Language == LanguageNames.CSharp ? "base" : "MyBase"; var disposeMethodParam = (disposeMethodKind is DisposeMethodKind.DisposeBool or DisposeMethodKind.DisposeCoreAsync) ? containingMethod.Language == LanguageNames.CSharp ? "bool" : "Boolean" : string.Empty; var disposeMethodName = disposeMethodKind == DisposeMethodKind.DisposeBool ? "Dispose" : disposeMethodKind.ToString(); var arg2 = $"{baseKeyword}.{disposeMethodName}({disposeMethodParam})"; var diagnostic = containingMethod.CreateDiagnostic(Rule, arg1, arg2); operationEndContext.ReportDiagnostic(diagnostic); } }); }); }); }
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); context.RegisterSyntaxNodeAction(AnalyzeMethodDeclaration, SyntaxKind.MethodDeclaration); }
protected sealed override void InitializeWorker(AnalysisContext context) => context.RegisterCompilationStartAction(compilationStartContext => CompilationAnalyzer.CreateAndRegisterActions(compilationStartContext, this));
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); // Security analyzer - analyze and report diagnostics on generated code. context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics); context.RegisterCompilationStartAction( (CompilationStartAnalysisContext compilationStartAnalysisContext) => { var wellKnownTypeProvider = WellKnownTypeProvider.GetOrCreate(compilationStartAnalysisContext.Compilation); if (!wellKnownTypeProvider.TryGetOrCreateTypeByMetadataName( WellKnownTypeNames.SystemNetSecurityProtocolType, out var securityProtocolTypeTypeSymbol) || !wellKnownTypeProvider.TryGetOrCreateTypeByMetadataName( WellKnownTypeNames.SystemNetServicePointManager, out var servicePointManagerTypeSymbol)) { return; } compilationStartAnalysisContext.RegisterOperationAction( (OperationAnalysisContext operationAnalysisContext) => { var fieldReferenceOperation = (IFieldReferenceOperation)operationAnalysisContext.Operation; // Make sure we're not inside an &= assignment like: // ServicePointManager.SecurityProtocol &= ~(SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11) // cuz &= is at worst, disabling protocol versions. if (IsReferencingSecurityProtocolType( fieldReferenceOperation, out var isDeprecatedProtocol, out var isHardCodedOkayProtocol) && null == fieldReferenceOperation.GetAncestor <ICompoundAssignmentOperation>( OperationKind.CompoundAssignment, IsAndEqualsServicePointManagerAssignment)) { if (isDeprecatedProtocol) { operationAnalysisContext.ReportDiagnostic( fieldReferenceOperation.CreateDiagnostic( DeprecatedRule, fieldReferenceOperation.Field.Name)); } else if (isHardCodedOkayProtocol) { operationAnalysisContext.ReportDiagnostic( fieldReferenceOperation.CreateDiagnostic( HardCodedRule, fieldReferenceOperation.Field.Name)); } } }, OperationKind.FieldReference); compilationStartAnalysisContext.RegisterOperationAction( (OperationAnalysisContext operationAnalysisContext) => { var assignmentOperation = (IAssignmentOperation)operationAnalysisContext.Operation; // Make sure this is an assignment operation for a SecurityProtocolType, and not // an assignment like: // ServicePointManager.SecurityProtocol &= ~(SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11) // cuz &= is at worst, disabling protocol versions. if (!securityProtocolTypeTypeSymbol.Equals(assignmentOperation.Target.Type) || (assignmentOperation is ICompoundAssignmentOperation compoundAssignmentOperation && IsAndEqualsServicePointManagerAssignment(compoundAssignmentOperation))) { return; } // Find the topmost operation with a bad bit set, unless we find an operation that would've been // flagged by the FieldReference callback above. IOperation?foundDeprecatedOperation = null; bool foundDeprecatedReference = false; IOperation?foundHardCodedOperation = null; bool foundHardCodedReference = false; foreach (IOperation childOperation in assignmentOperation.Value.DescendantsAndSelf()) { if (childOperation is IFieldReferenceOperation fieldReferenceOperation && IsReferencingSecurityProtocolType( fieldReferenceOperation, out var isDeprecatedProtocol, out var isHardCodedOkayProtocol)) { if (isDeprecatedProtocol) { foundDeprecatedReference = true; } else if (isHardCodedOkayProtocol) { foundHardCodedReference = true; } if (foundDeprecatedReference && foundHardCodedReference) { return; } } if (childOperation.ConstantValue.HasValue && childOperation.ConstantValue.Value is int integerValue) { if (foundDeprecatedOperation == null && // Only want the first. (integerValue & UnsafeBits) != 0) { foundDeprecatedOperation = childOperation; } if (foundHardCodedOperation == null && // Only want the first. (integerValue & HardCodedBits) != 0) { foundHardCodedOperation = childOperation; } } } if (foundDeprecatedOperation != null && !foundDeprecatedReference) { operationAnalysisContext.ReportDiagnostic( foundDeprecatedOperation.CreateDiagnostic( DeprecatedRule, foundDeprecatedOperation.ConstantValue)); } if (foundHardCodedOperation != null && !foundHardCodedReference) { operationAnalysisContext.ReportDiagnostic( foundHardCodedOperation.CreateDiagnostic( HardCodedRule, foundHardCodedOperation.ConstantValue)); } }, OperationKind.SimpleAssignment, OperationKind.CompoundAssignment); return; // Local function(s). bool IsReferencingSecurityProtocolType( IFieldReferenceOperation fieldReferenceOperation, out bool isDeprecatedProtocol, out bool isHardCodedOkayProtocol) { RoslynDebug.Assert(securityProtocolTypeTypeSymbol != null); if (securityProtocolTypeTypeSymbol.Equals(fieldReferenceOperation.Field.ContainingType)) { if (HardCodedSafeProtocolMetadataNames.Contains(fieldReferenceOperation.Field.Name)) { isHardCodedOkayProtocol = true; isDeprecatedProtocol = false; } else if (fieldReferenceOperation.Field.Name == SystemDefaultName) { isHardCodedOkayProtocol = false; isDeprecatedProtocol = false; } else { isDeprecatedProtocol = true; isHardCodedOkayProtocol = false; } return(true); } else { isHardCodedOkayProtocol = false; isDeprecatedProtocol = false; return(false); } } bool IsAndEqualsServicePointManagerAssignment(ICompoundAssignmentOperation compoundAssignmentOperation) { RoslynDebug.Assert(servicePointManagerTypeSymbol != null); return(compoundAssignmentOperation.OperatorKind == BinaryOperatorKind.And && compoundAssignmentOperation.Target is IPropertyReferenceOperation targetPropertyReference && targetPropertyReference.Instance == null && servicePointManagerTypeSymbol.Equals(targetPropertyReference.Property.ContainingType) && targetPropertyReference.Property.MetadataName == "SecurityProtocol"); } }); }
public override void Initialize(AnalysisContext context) { context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.ClassDeclaration); }
public override void Initialize(AnalysisContext context) { // TODO: Consider registering other actions that act on syntax instead of or in addition to symbols // See https://github.com/dotnet/roslyn/blob/master/docs/analyzers/Analyzer%20Actions%20Semantics.md for more information context.RegisterSyntaxNodeAction(AnalizeNode, SyntaxKind.LocalDeclarationStatement); }
public override void Initialize(AnalysisContext context) => context.RegisterCompilationStartAction(AnalyzeCompilation);
public override void Initialize(AnalysisContext context) { context.EnableConcurrentExecution(); context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None); }
protected override void InitializeWorker(AnalysisContext context) => context.RegisterSyntaxNodeAction(AnalyzeSyntax, _syntaxKinds);
public override void Initialize(AnalysisContext context) { context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method); }
public override void Initialize(AnalysisContext context) => context.RegisterSyntaxNodeAction(Analyzer, SyntaxKind.NumericLiteralExpression);