public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            var suppressAll = IsMarkedWithAttribute(context.Compilation.Assembly, "SmartAnalyzers.CSharpExtensions.Annotations.InitRequiredForNotNullAttribute");

            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                if (suppressAll)
                {
                    context.ReportSuppression(Suppression.Create(SuppressionDescriptor, diagnostic));
                    continue;
                }

                var root = diagnostic.Location.SourceTree.GetRoot().FindNode(diagnostic.Location.SourceSpan);
                if (root is MemberDeclarationSyntax memberDeclaration)
                {
                    if (HasAttributeWithInitGuarantee(memberDeclaration.AttributeLists))
                    {
                        context.ReportSuppression(Suppression.Create(SuppressionDescriptor, diagnostic));
                    }
                    else
                    {
                        var typeDeclaration = SyntaxHelper.FindNearestContainer <TypeDeclarationSyntax>(memberDeclaration);
                        if (typeDeclaration != null && HasAttributeWithInitGuarantee(typeDeclaration.AttributeLists))
                        {
                            context.ReportSuppression(Suppression.Create(SuppressionDescriptor, diagnostic));
                        }
                    }
                }
            }
        }
Exemplo n.º 2
0
        private void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var fieldDeclarationSyntax = context.GetSuppressibleNode <VariableDeclaratorSyntax>(diagnostic);

            if (fieldDeclarationSyntax == null)
            {
                return;
            }

            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);

            if (!(model.GetDeclaredSymbol(fieldDeclarationSyntax) is IFieldSymbol fieldSymbol))
            {
                return;
            }

            if (!IsSuppressable(fieldSymbol))
            {
                return;
            }

            foreach (var descriptor in SupportedSuppressions.Where(d => d.SuppressedDiagnosticId == diagnostic.Id))
            {
                context.ReportSuppression(Suppression.Create(descriptor, diagnostic));
            }
        }
Exemplo n.º 3
0
        private void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var node = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken).FindNode(diagnostic.Location.SourceSpan);

            if (node == null)
            {
                return;
            }

            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);

            if (!(model.GetDeclaredSymbol(node) is IFieldSymbol fieldSymbol))
            {
                return;
            }

            if (!fieldSymbol.GetAttributes().Any(a => a.AttributeClass.Matches(typeof(UnityEngine.SerializeField)) || a.AttributeClass.Matches(typeof(UnityEngine.SerializeReference))))
            {
                return;
            }

            foreach (var descriptor in SupportedSuppressions.Where(d => d.SuppressedDiagnosticId == diagnostic.Id))
            {
                context.ReportSuppression(Suppression.Create(descriptor, diagnostic));
            }
        }
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                var node = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken).FindNode(diagnostic.Location.SourceSpan);

                if (node == null)
                {
                    continue;
                }

                if (!(node is ParameterSyntax parameter))
                {
                    continue;
                }

                // cheapest checks first
                if (!(parameter.Type is NameSyntax))
                {
                    return;
                }

                if (context.GetSemanticModel(node.SyntaxTree).GetTypeInfo(parameter.Type).Type.IsCancellationToken())
                {
                    context.ReportSuppression(SuppressionDescriptors.CancellationTokenParameterUnused, diagnostic);
                }
            }
        }
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            if (context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.XunitFactAttribute) is not {
            } factAttribute)
            {
                return;
            }

            var knownTestAttributes = new ConcurrentDictionary <INamedTypeSymbol, bool>();

            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                // The diagnostic is reported on the test method
                if (diagnostic.Location.SourceTree is not {
                } tree)
                {
                    continue;
                }

                var root = tree.GetRoot(context.CancellationToken);
                var node = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);

                var semanticModel  = context.GetSemanticModel(tree);
                var declaredSymbol = semanticModel.GetDeclaredSymbol(node, context.CancellationToken);
                if (declaredSymbol is IMethodSymbol method &&
                    method.IsXUnitTestMethod(knownTestAttributes, factAttribute))
                {
                    context.ReportSuppression(Suppression.Create(Rule, diagnostic));
                }
            }
        }
Exemplo n.º 6
0
 public override void ReportSuppressions(SuppressionAnalysisContext context)
 {
     foreach (Diagnostic diagnostic in context.ReportedDiagnostics)
     {
         context.ReportSuppression(Suppression.Create(SupportedSuppressions[0], diagnostic));
     }
 }
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                SyntaxNode?node = diagnostic.Location.SourceTree?.GetRoot(context.CancellationToken)
                                  .FindNode(diagnostic.Location.SourceSpan);

                if (node is null)
                {
                    continue;
                }

                string fieldName = node.ToString();

                var classDeclaration = node.Ancestors().OfType <ClassDeclarationSyntax>().First();
                var methods          = classDeclaration.Members.OfType <MethodDeclarationSyntax>().ToArray();

                foreach (var method in methods)
                {
                    var allAttributes = method.AttributeLists.SelectMany(list => list.Attributes.Select(a => a.Name.ToString()))
                                        .ToImmutableHashSet();
                    if (allAttributes.Contains("SetUp") || allAttributes.Contains("OneTimeSetUp"))
                    {
                        // Find (OneTime)SetUps method and check for assignment to this field.
                        if (FieldIsAssignedIn(method, fieldName))
                        {
                            context.ReportSuppression(Suppression.Create(NullableFieldInitializedInSetUp, diagnostic));
                        }
                    }
                }
            }
        }
        private void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var node = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken).FindNode(diagnostic.Location.SourceSpan);

            if (node == null)
            {
                return;
            }

            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);

            if (!(model.GetDeclaredSymbol(node) is IFieldSymbol fieldSymbol))
            {
                return;
            }

            if (!IsSuppressable(fieldSymbol))
            {
                return;
            }

            foreach (var descriptor in SupportedSuppressions.Where(d => d.SuppressedDiagnosticId == diagnostic.Id))
            {
                context.ReportSuppression(Suppression.Create(descriptor, diagnostic));
            }
        }
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            var implAttr = context.Compilation.GetTypeByMetadataName(MeansImplicitAssignmentAttribute);

            foreach (var reportedDiagnostic in context.ReportedDiagnostics)
            {
                if (reportedDiagnostic.Id != Diagnostics.MeansImplicitAssignment.SuppressedDiagnosticId)
                {
                    continue;
                }

                var node = reportedDiagnostic.Location.SourceTree?.GetRoot(context.CancellationToken).FindNode(reportedDiagnostic.Location.SourceSpan);
                if (node == null)
                {
                    continue;
                }

                var symbol = context.GetSemanticModel(reportedDiagnostic.Location.SourceTree).GetDeclaredSymbol(node);

                if (symbol == null || !symbol.GetAttributes().Any(a =>
                                                                  a.AttributeClass?.GetAttributes().Any(attr =>
                                                                                                        SymbolEqualityComparer.Default.Equals(attr.AttributeClass, implAttr)) == true))
                {
                    continue;
                }

                context.ReportSuppression(Suppression.Create(
                                              Diagnostics.MeansImplicitAssignment,
                                              reportedDiagnostic));
            }
        }
        private static void AnalyzeBinaryExpression(Diagnostic diagnostic, SuppressionAnalysisContext context, BinaryExpressionSyntax binaryExpression)
        {
            switch (binaryExpression.Kind())
            {
            case SyntaxKind.EqualsExpression:
            case SyntaxKind.NotEqualsExpression:
                break;

            default:
                return;
            }

            if (!binaryExpression.Right.IsKind(SyntaxKind.NullLiteralExpression))
            {
                return;
            }

            var model = context.GetSemanticModel(binaryExpression.SyntaxTree);

            if (model == null)
            {
                return;
            }

            var type = model.GetTypeInfo(binaryExpression.Left);

            if (type.Type == null)
            {
                return;
            }

            if (!type.Type.Extends(typeof(UnityEngine.Object)))
            {
                return;
            }

            if (diagnostic.Id == NullCoalescingRule.SuppressedDiagnosticId)
            {
                context.ReportSuppression(Suppression.Create(NullCoalescingRule, diagnostic));
            }
            else if (diagnostic.Id == NullPropagationRule.SuppressedDiagnosticId)
            {
                context.ReportSuppression(Suppression.Create(NullPropagationRule, diagnostic));
            }
        }
        private static void AnalyzeFields(VariableDeclaratorSyntax declarator, Diagnostic diagnostic, SuppressionAnalysisContext context, SyntaxNode root)
        {
            var declarationSyntax = declarator.FirstAncestorOrSelf <FieldDeclarationSyntax>();

            //suppress for fields that are not private and not static => statics cannot be set in editor and are not shown in the inspector and cannot be set there
            if (!declarationSyntax.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PrivateKeyword) || modifier.IsKind(SyntaxKind.StaticKeyword)) &&
                !declarationSyntax.AttributeLists.Any(attributeList => attributeList.Attributes.Any(attribute => attribute.Name.ToString() == nameof(UnityEngine.HideInInspector))))
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
                return;
            }

            //check for serializefield attribute => variable could be set in editor
            if (declarationSyntax.AttributeLists.Any(attributeList => attributeList.Attributes.Any(attribute => attribute.Name.ToString() == nameof(UnityEngine.SerializeField))))
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
                return;
            }

            var symbol = GetSymbol(diagnostic.Location.SourceTree, declarationSyntax.Declaration.Type, context);

            if (!symbol.Extends(typeof(UnityEngine.Object)))
            {
                return;
            }

            var methodBodies = MethodBodies(root)
                               .ToList();

            //check for valid assignments
            if (IsAssignedTo(declarator.Identifier.Text, methodBodies))
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
                return;
            }

            //check for existence of this variable in any assigned property
            foreach (string variable in AssignedProperties(root, methodBodies))
            {
                if (variable == declarator.Identifier.Text)
                {
                    context.ReportSuppression(Suppression.Create(Rule, diagnostic));
                }
            }
        }
        private void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var location   = diagnostic.Location;
            var sourceTree = location.SourceTree;
            var root       = sourceTree.GetRoot(context.CancellationToken);
            var node       = root.FindNode(location.SourceSpan);
            var model      = context.GetSemanticModel(location.SourceTree);
            var symbols    = new List <ISymbol>();

            switch (node)
            {
            case MethodDeclarationSyntax method:
                symbols.Add(model.GetDeclaredSymbol(method));
                break;

            case VariableDeclaratorSyntax vdec:
                symbols.Add(model.GetDeclaredSymbol(vdec));
                break;

            case FieldDeclarationSyntax fdec:
                symbols.AddRange(fdec.Declaration.Variables.Select(v => model.GetDeclaredSymbol(v)));
                break;
            }

            var reportableSymbols = symbols
                                    .Where(IsReportable)
                                    .ToList();

            if (!reportableSymbols.Any())
            {
                return;
            }

            if (reportableSymbols.FirstOrDefault() is IMethodSymbol)
            {
                context.ReportSuppression(Suppression.Create(ContextMenuRule, diagnostic));
            }
            else
            {
                foreach (var descriptor in SupportedSuppressions.Where(d => d.SuppressedDiagnosticId == diagnostic.Id))
                {
                    context.ReportSuppression(Suppression.Create(descriptor, diagnostic));
                }
            }
        }
Exemplo n.º 13
0
 public override void ReportSuppressions(SuppressionAnalysisContext context)
 {
     foreach (var diagnostic in context.ReportedDiagnostics)
     {
         if (diagnostic.GetMessage(CultureInfo.InvariantCulture) is { } message&&
             IsOut(message))
         {
             context.ReportSuppression(Suppression.Create(Descriptor, diagnostic));
         }
Exemplo n.º 14
0
 public override void ReportSuppressions(SuppressionAnalysisContext context)
 {
     foreach (Diagnostic diagnostic in context.ReportedDiagnostics)
     {
         if (diagnostic.GetMessage().Contains("TestStruct.X")) // Filtering on the message is gross and terrible. Don't actually do this in a real suppressor.
         {
             context.ReportSuppression(Suppression.Create(SupportedSuppressions[0], diagnostic));
         }
     }
 }
        private static void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);
            var methodDeclarationSyntax = context.GetSuppressibleNode <MethodDeclarationSyntax>(diagnostic);

            // Reuse the same detection logic regarding decorated methods with *InitializeOnLoadMethodAttribute
            if (InitializeOnLoadMethodAnalyzer.MethodMatches(methodDeclarationSyntax, model, out _, out _))
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
            }
        }
        private void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            try
            {
                var node = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken).FindNode(diagnostic.Location.SourceSpan);

                if (node is PropertyDeclarationSyntax prop)
                {
                    if (!ContainsMustInitialize(prop, context, prop.Identifier.ValueText))
                    {
                        return;
                    }
                }
                else if ((node.Parent.Parent) is FieldDeclarationSyntax f)
                {
                    if (!ContainsMustInitialize(f, context, (node as VariableDeclaratorSyntax).Identifier.Text))
                    {
                        return;
                    }
                }
                else if (node is ConstructorDeclarationSyntax)
                {
                    var regex = new Regex(@"(\S*)\s*'(.*)'");
                    var match = regex.Match(diagnostic.GetMessage());
                    var type  = match.Groups[1].Value;
                    var name  = match.Groups[2].Value;

                    if (type == "field")
                    {
                        var fieldDecl = node.Parent.DescendantNodes().OfType <FieldDeclarationSyntax>().First(n => n.Declaration.Variables.Any(v => v.Identifier.ValueText == name));
                        if (!ContainsMustInitialize(fieldDecl, context, name))
                        {
                            return;
                        }
                    }
                    else
                    {
                        var propDecl = node.Parent.DescendantNodes().OfType <PropertyDeclarationSyntax>().First(p => p.Identifier.ValueText == name);
                        if (!ContainsMustInitialize(propDecl, context, name))
                        {
                            return;
                        }
                    }
                }

                context.ReportSuppression(Suppression.Create(MustInitializeRule, diagnostic));
            }
            catch (Exception ex)
            {
                Logger.LogError(ex);
                throw;
            }
        }
        private static void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var sourceTree = diagnostic.Location.SourceTree;
            var root       = sourceTree.GetRoot(context.CancellationToken);
            var node       = root.FindNode(diagnostic.Location.SourceSpan);
            var model      = context.GetSemanticModel(diagnostic.Location.SourceTree);

            // Reuse the same detection logic regarding decorated methods with *InitializeOnLoadMethodAttribute
            if (InitializeOnLoadMethodAnalyzer.MethodMatches(node, model, out _, out _))
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
            }
        }
        private static void AnalyzeProperties(PropertyDeclarationSyntax declarationSyntax, Diagnostic diagnostic, SuppressionAnalysisContext context, SyntaxNode root)
        {
            var symbol = GetSymbol(diagnostic.Location.SourceTree, declarationSyntax.Type, context);

            if (!symbol.Extends(typeof(UnityEngine.Object)))
            {
                return;
            }

            //check for valid assignments
            if (IsAssignedTo(declarationSyntax.Identifier.Text, MethodBodies(root)))
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
            }
        }
Exemplo n.º 19
0
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                if (!(GetSymbolForDiagnostic(diagnostic, context) is IMethodSymbol symbol))
                {
                    return;
                }

                if (symbol.IsHarmonyMethod())
                {
                    context.ReportSuppression(Suppression.Create(suppressionDescriptor, diagnostic));
                }
            }
        }
Exemplo n.º 20
0
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                var root = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken);
                if (root.FindNode(diagnostic.Location.SourceSpan) is { } node&&
                    node.TryFirstAncestorOrSelf(out IdentifierNameSyntax? identifierName) &&
                    context.GetSemanticModel(identifierName.SyntaxTree) is { } semanticModel)
                {
                    if (semanticModel.TryGetSymbol(identifierName, context.CancellationToken, out var symbol) &&
                        FieldOrProperty.TryCreate(symbol, out var fieldOrProperty) &&
                        fieldOrProperty.Type == KnownSymbols.DependencyPropertyKey)
                    {
                        context.ReportSuppression(Suppression.Create(Descriptor, diagnostic));
                    }

                    if (identifierName.Parent is MethodDeclarationSyntax method &&
                        ClrMethod.IsAttachedSet(method, semanticModel, context.CancellationToken, out _, out _))
                    {
                        context.ReportSuppression(Suppression.Create(Descriptor, diagnostic));
                    }
                }
            }
        }
Exemplo n.º 21
0
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                if (!(GetSymbolForDiagnostic(diagnostic, context) is IFieldSymbol symbol))
                {
                    return;
                }

                if (symbol.GetAttributes().Any(x => IsRightAttribute(x)))
                {
                    context.ReportSuppression(Suppression.Create(GetSuppressionDescriptor(), diagnostic));
                }

                bool IsRightAttribute(AttributeData attribute) => GetSuppressorAttributeName().Contains(attribute.AttributeClass.Name);
            }
        }
Exemplo n.º 22
0
        private void AnalyzeBinaryExpression(Diagnostic diagnostic, SuppressionAnalysisContext context, BinaryExpressionSyntax binaryExpression)
        {
            switch (binaryExpression.Kind())
            {
            case SyntaxKind.EqualsExpression:
            case SyntaxKind.NotEqualsExpression:
                if (!binaryExpression.Right.IsKind(SyntaxKind.NullLiteralExpression))
                {
                    return;
                }
                break;

            case SyntaxKind.CoalesceExpression:
                break;

            default:
                return;
            }

            var model = context.GetSemanticModel(binaryExpression.SyntaxTree);

            if (model == null)
            {
                return;
            }

            var type = model.GetTypeInfo(binaryExpression.Left);

            if (type.Type == null)
            {
                return;
            }

            if (!type.Type.Extends(typeof(UnityEngine.Object)))
            {
                return;
            }

            var rule = SupportedSuppressions.FirstOrDefault(r => r.SuppressedDiagnosticId == diagnostic.Id);

            if (rule != null)
            {
                context.ReportSuppression(Suppression.Create(rule, diagnostic));
            }
        }
        private static void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var sourceTree = diagnostic.Location.SourceTree;
            var root       = sourceTree.GetRoot(context.CancellationToken);

            var methodDeclarationSyntax = context.GetSuppressibleNode <MethodDeclarationSyntax>(diagnostic);

            if (methodDeclarationSyntax == null)
            {
                return;
            }

            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);

            if (!(model.GetDeclaredSymbol(methodDeclarationSyntax) is IMethodSymbol methodSymbol))
            {
                return;
            }

            var typeSymbol = methodSymbol.ContainingType;

            if (!typeSymbol.Extends(typeof(UnityEngine.MonoBehaviour)))
            {
                return;
            }

            while (typeSymbol.ContainingType != null && typeSymbol.ContainingType.Extends(typeof(UnityEngine.MonoBehaviour)))
            {
                typeSymbol = typeSymbol.ContainingType;
            }

            var references = new List <InvocationExpressionSyntax>();

            foreach (var typeNode in typeSymbol.Locations.Select(location => root.FindNode(location.SourceSpan)))
            {
                references.AddRange(typeNode.DescendantNodes()
                                    .OfType <InvocationExpressionSyntax>()
                                    .Where(e => MethodInvocationAnalyzer.InvocationMatches(e, out string argument) && argument == methodSymbol.Name));
            }

            if (references.Any())
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
            }
        }
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                SyntaxNode?node = diagnostic.Location.SourceTree?.GetRoot(context.CancellationToken)
                                  .FindNode(diagnostic.Location.SourceSpan);

                if (node is null)
                {
                    continue;
                }

                if (ShouldBeSuppressed(node))
                {
                    context.ReportSuppression(Suppression.Create(SuppressionDescriptors[diagnostic.Id], diagnostic));
                }
            }
        }
        public override void ReportSuppressions(SuppressionAnalysisContext context)
        {
            foreach (var diagnostic in context.ReportedDiagnostics)
            {
                SyntaxNode?node = diagnostic.Location.SourceTree?.GetRoot(context.CancellationToken)
                                  .FindNode(diagnostic.Location.SourceSpan);

                if (node is null)
                {
                    continue;
                }

                // Was the offending variable assigned or verified to be not null inside an Assert.Multiple?
                // NUnit doesn't throw on failures and therefore the compiler is correct.
                if (ShouldBeSuppressed(node, out SyntaxNode? suppressionCause) && !IsInsideAssertMultiple(suppressionCause))
                {
                    context.ReportSuppression(Suppression.Create(SuppressionDescriptors[diagnostic.Id], diagnostic));
                }
            }
        }
        private void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var node = context.GetSuppressibleNode <SyntaxNode>(diagnostic, n => n is ParameterSyntax || n is MethodDeclarationSyntax);

            if (node is ParameterSyntax)
            {
                node = node
                       .Ancestors()
                       .OfType <MethodDeclarationSyntax>()
                       .FirstOrDefault();
            }

            if (node == null)
            {
                return;
            }

            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);

            if (!(model.GetDeclaredSymbol(node) is IMethodSymbol methodSymbol))
            {
                return;
            }

            var scriptInfo = new ScriptInfo(methodSymbol.ContainingType);

            if (!scriptInfo.IsMessage(methodSymbol))
            {
                return;
            }

            foreach (var suppression in SupportedSuppressions)
            {
                if (suppression.SuppressedDiagnosticId == diagnostic.Id)
                {
                    context.ReportSuppression(Suppression.Create(suppression, diagnostic));
                }
            }
        }
        private static void SuppressMarkMethodsAsStaticDiagnosticIfNeeded(SuppressionAnalysisContext context, Diagnostic diagnostic)
        {
            SemanticModel model           = context.GetSemanticModel(diagnostic.Location.SourceTree);
            ISymbol       diagnosedSymbol = model.GetDeclaredSymbol(diagnostic.Location.SourceTree.GetRoot(context.CancellationToken).FindNode(diagnostic.Location.SourceSpan), context.CancellationToken);

            if (diagnosedSymbol.Kind != SymbolKind.Method)
            {
                return;
            }

            if (FindContainingEntryPointTypeAndManagedType(diagnosedSymbol.ContainingType) is (INamedTypeSymbol entryPointMarshallerType, INamedTypeSymbol managedType))
            {
                bool isLinearCollectionMarshaller = ManualTypeMarshallingHelper.IsLinearCollectionEntryPoint(entryPointMarshallerType);
                (MarshallerShape _, StatefulMarshallerShapeHelper.MarshallerMethods methods) = StatefulMarshallerShapeHelper.GetShapeForType(diagnosedSymbol.ContainingType, managedType, isLinearCollectionMarshaller, context.Compilation);
                if (methods.IsShapeMethod((IMethodSymbol)diagnosedSymbol))
                {
                    // If we are a method of the shape on the stateful marshaller shape, then we need to be our current shape.
                    // So, suppress the diagnostic to make this method static, as that would break the shape.
                    context.ReportSuppression(Suppression.Create(MarkMethodsAsStaticSuppression, diagnostic));
                }
            }
        }
        private static void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var sourceTree = diagnostic.Location.SourceTree;
            var root       = sourceTree.GetRoot(context.CancellationToken);
            var node       = root.FindNode(diagnostic.Location.SourceSpan);

            if (!(node is MethodDeclarationSyntax method))
            {
                return;
            }

            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);

            if (!(model.GetDeclaredSymbol(method) is IMethodSymbol methodSymbol))
            {
                return;
            }

            if (IsSuppressable(methodSymbol))
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
            }
        }
Exemplo n.º 29
0
        private static void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var sourceTree = diagnostic.Location.SourceTree;
            var root       = sourceTree.GetRoot(context.CancellationToken);
            var node       = root.FindNode(diagnostic.Location.SourceSpan);

            if (!(node is MethodDeclarationSyntax method))
            {
                return;
            }

            var model = context.GetSemanticModel(diagnostic.Location.SourceTree);

            if (!(model.GetDeclaredSymbol(method) is IMethodSymbol methodSymbol))
            {
                return;
            }

            var typeSymbol = methodSymbol.ContainingType;

            if (!typeSymbol.Extends(typeof(UnityEngine.MonoBehaviour)))
            {
                return;
            }

            var references = root
                             .DescendantNodes()
                             .OfType <InvocationExpressionSyntax>()
                             .Where(e => IsMatchingArgument(e, methodSymbol.Name))
                             .Where(e => IsMatchingIdentifier(e.Expression));

            if (references.Any())
            {
                context.ReportSuppression(Suppression.Create(Rule, diagnostic));
            }
        }
        private static void AnalyzeDiagnostic(Diagnostic diagnostic, SuppressionAnalysisContext context)
        {
            var node = diagnostic.Location.SourceTree.GetRoot(context.CancellationToken).FindNode(diagnostic.Location.SourceSpan);

            if (node == null)
            {
                return;
            }

            if (!node.IsKind(SyntaxKind.ConditionalExpression))
            {
                return;
            }

            var cond = (ConditionalExpressionSyntax)node;

            switch (cond.Condition.Kind())
            {
            case SyntaxKind.EqualsExpression:
            case SyntaxKind.NotEqualsExpression:
                break;

            default:
                return;
            }

            var binary = (BinaryExpressionSyntax)cond.Condition;

            if (!binary.Right.IsKind(SyntaxKind.NullLiteralExpression))
            {
                return;
            }

            var model = context.GetSemanticModel(node.SyntaxTree);

            if (model == null)
            {
                return;
            }

            var type = model.GetTypeInfo(binary.Left);

            if (type.Type == null)
            {
                return;
            }

            if (!type.Type.Extends(typeof(UnityEngine.Object)))
            {
                return;
            }

            if (diagnostic.Id == NullCoalescingRule.SuppressedDiagnosticId)
            {
                context.ReportSuppression(Suppression.Create(NullCoalescingRule, diagnostic));
            }
            else if (diagnostic.Id == NullPropagationRule.SuppressedDiagnosticId)
            {
                context.ReportSuppression(Suppression.Create(NullPropagationRule, diagnostic));
            }
        }