private Diagnostic AnalyzeSyntax( SemanticModel semanticModel, CodeStyleOption <ExpressionBodyPreference> option, LambdaExpressionSyntax declaration, CancellationToken cancellationToken) { if (CanOfferUseExpressionBody(option.Value, declaration)) { var location = GetDiagnosticLocation(declaration); var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); var properties = ImmutableDictionary <string, string> .Empty; return(DiagnosticHelper.Create( CreateDescriptorWithId(UseExpressionBodyTitle, UseExpressionBodyTitle), location, option.Notification.Severity, additionalLocations, properties)); } if (CanOfferUseBlockBody(semanticModel, option.Value, declaration, cancellationToken)) { // They have an expression body. Create a diagnostic to convert it to a block // if they don't want expression bodies for this member. var location = GetDiagnosticLocation(declaration); var properties = ImmutableDictionary <string, string> .Empty; var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); return(DiagnosticHelper.Create( CreateDescriptorWithId(UseBlockBodyTitle, UseBlockBodyTitle), location, option.Notification.Severity, additionalLocations, properties)); } return(null); }
private Diagnostic AnalyzeSyntax( SemanticModel semanticModel, OptionSet optionSet, LambdaExpressionSyntax declaration, CancellationToken cancellationToken) { var preferExpressionBodiedOption = optionSet.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedLambdas); var severity = preferExpressionBodiedOption.Notification.Severity; if (CanOfferUseExpressionBody(optionSet, declaration, forAnalyzer: true)) { var location = GetDiagnosticLocation(declaration); var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); var properties = ImmutableDictionary <string, string> .Empty.Add(nameof(UseExpressionBody), ""); return(DiagnosticHelper.Create( CreateDescriptorWithId(DescriptorId, UseExpressionBodyTitle, UseExpressionBodyTitle), location, severity, additionalLocations, properties)); } var(canOffer, fixesError) = CanOfferUseBlockBody( semanticModel, optionSet, declaration, forAnalyzer: true, cancellationToken); if (canOffer) { // They have an expression body. Create a diagnostic to convert it to a block // if they don't want expression bodies for this member. var location = GetDiagnosticLocation(declaration); var properties = ImmutableDictionary <string, string> .Empty; if (fixesError) { properties = properties.Add(FixesError, ""); } var additionalLocations = ImmutableArray.Create(declaration.GetLocation()); return(DiagnosticHelper.Create( CreateDescriptorWithId(DescriptorId, UseBlockBodyTitle, UseBlockBodyTitle), location, severity, additionalLocations, properties)); } return(null); }
private void AnalyzeLambda(SyntaxNodeAnalysisContext context) { LambdaExpressionSyntax lambdaExpressionSyntax = (LambdaExpressionSyntax)context.Node; if (lambdaExpressionSyntax.AsyncKeyword.Kind() != SyntaxKind.AsyncKeyword) { return; } var retValType = context.SemanticModel.GetSymbolInfo(lambdaExpressionSyntax); if (retValType.Symbol is null) { return; } if (retValType.Symbol is IMethodSymbol method && method.ReturnType.SpecialType == SpecialType.System_Void) { context.ReportDiagnostic(Diagnostic.Create(Rule, lambdaExpressionSyntax.GetLocation())); } }
private void AnalyzePredicate(SyntaxNodeAnalysisContext context, SyntaxToken methodName, LambdaExpressionSyntax lambdaExpression) { if (GetParameters(lambdaExpression) is var parameters && parameters.Length == 1 && lambdaExpression.ExpressionBody is ExpressionSyntax body) { var parameterName = parameters[0].Identifier.ValueText; var operands = GetBinaryExpressionOperands(body, SyntaxKind.LogicalAndExpression) .Select(operand => { var propertyName = GetEqualParameterPropertyExpression(operand, parameterName); IPropertySymbol?propertySymbol = null; if (propertyName != null) { var propertyInfo = context.SemanticModel.GetSymbolInfo(propertyName, context.CancellationToken); propertySymbol = propertyInfo.Symbol as IPropertySymbol; } return(new BinaryOperatorOperand(operand, propertySymbol)); }) .ToList(); if (operands.Count == 0) { return; } var columns = operands .Where(c => c.ColumnSymbol != null) .Select(c => c.ColumnSymbol !) .ToList(); // TODO(jpg): check if this is true for inherited properties Debug.Assert( columns.Select(c => c.ContainingType).Distinct().Count() <= 1, "All properties must be contained in the same type." ); var type = columns[0].ContainingType; var declaredPrimaryKeys = type.GetMembers().OfType <IPropertySymbol>().Where(IsPrimaryKey); var usedPrimaryKeys = columns.Where(IsPrimaryKey); // TODO(jpg): check if this is true for inherited properties Debug.Assert( !usedPrimaryKeys.Except(declaredPrimaryKeys).Any(), "usedPrimaryKeys ⊆ declaredPrimaryKeys" ); var unusedPrimaryKeys = declaredPrimaryKeys.Except(usedPrimaryKeys); if (unusedPrimaryKeys.Any()) { return; } var usedNonPrimaryKeys = operands .Where(c => c.ColumnSymbol == null || !IsPrimaryKey(c.ColumnSymbol)) .ToList(); if (usedNonPrimaryKeys.Count == 0) { return; } var diagnostic = Diagnostic.Create( descriptor: DiagnosticDescriptors.RemoveUnnecessaryConditionsFromPredicate, location: methodName.GetLocation(), additionalLocations: new[] { lambdaExpression.GetLocation() }.Concat(usedNonPrimaryKeys.Select(c => c.Expression.GetLocation())) ); context.ReportDiagnostic(diagnostic); } }