private IEnumerable <Diagnostic> Analyze(INamedTypeSymbol marker, INamedTypeSymbol target, SemanticModel semanticModel,
                                          VariableDeclarationSyntax varDeclSyntax)
 {
     if (semanticModel.GetSymbolInfo(varDeclSyntax.Type).Symbol is not INamedTypeSymbol type)
     {
         yield break;
     }
     if (!type.IsGenericType ||
         type.GetAttributes()
         .FirstOrDefault(a =>
                         SymbolEqualityComparer
                         .Default.Equals(a.AttributeClass, marker)) is not AttributeData genericTypeAttribute)
     {
         yield break;
     }
     if (genericTypeAttribute.ConstructorArguments.FirstOrDefault().Value is not int genericIndex)
     {
         yield break;
     }
     if (type.TypeArguments.ElementAtOrDefault(genericIndex) is not INamedTypeSymbol targetType)
     {
         yield break;
     }
     if (!targetType.GetAttributes().Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, target)))
     {
         yield return(Diagnostic.Create(Rule, varDeclSyntax.GetLocation(), targetType.Name));
     }
 }
Exemplo n.º 2
0
        private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
        {
            VariableDeclarationSyntax variableDeclaration = (context.Node as LocalDeclarationStatementSyntax).Declaration;
            bool isTypeApparent = IsTypeApparentInDeclaration(variableDeclaration, context.SemanticModel, context.CancellationToken);

            if (isTypeApparent && !variableDeclaration.Type.IsVar)
            {
                context.ReportDiagnostic(
                    Diagnostic.Create(
                        _rule,
                        variableDeclaration.GetLocation(),
                        "Implicit type decalaration should be used"));
            }
            if (!isTypeApparent && variableDeclaration.Type.IsVar)
            {
                context.ReportDiagnostic(
                    Diagnostic.Create(
                        _rule,
                        variableDeclaration.GetLocation(),
                        "Explicit type decalaration should be used"));
            }
        }
        private static void AnalyzeVariable(SyntaxNodeAnalysisContext context)
        {
            VariableDeclarationSyntax node = (VariableDeclarationSyntax)context.Node;

            if (Helper.IsInTestClass(context))
            {
                return;
            }

            var variables = node.Variables;

            if (!variables.Any())
            {
                return;
            }
            foreach (var variable in variables)
            {
                if (!IsPositiveName(variable.Identifier.Text))
                {
                    CreateDiagnostic(context, node.GetLocation());
                }
            }
        }