Standardise roslyn on registercompilationstart

Robust.Analyzers/AccessAnalyzer.cs

@@ -31,14 +31,27 @@ public override void Initialize(AnalysisContext context)
         {
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
             context.EnableConcurrentExecution();
-            context.RegisterOperationAction(CheckFriendship,
-                OperationKind.FieldReference,
-                OperationKind.PropertyReference,
-                OperationKind.MethodReference,
-                OperationKind.Invocation);
+            context.RegisterCompilationStartAction(compilationContext =>
+            {
+                var friendAttribute = compilationContext.Compilation.GetTypeByMetadataName(AccessAttributeType);
+                if (friendAttribute is null)
+                    return;
+
+                var pureAttribute = compilationContext.Compilation.GetTypeByMetadataName(PureAttributeType);
+
+                compilationContext.RegisterOperationAction(
+                    operationContext => CheckFriendship(operationContext, friendAttribute, pureAttribute),
+                    OperationKind.FieldReference,
+                    OperationKind.PropertyReference,
+                    OperationKind.MethodReference,
+                    OperationKind.Invocation);
+            });
         }
 
-        private void CheckFriendship(OperationAnalysisContext context)
+        private void CheckFriendship(
+            OperationAnalysisContext context,
+            INamedTypeSymbol friendAttribute,
+            INamedTypeSymbol pureAttribute)
         {
             var operation = context.Operation;
 
@@ -71,15 +84,12 @@ private void CheckFriendship(OperationAnalysisContext context)
             // Get the info of the type defining the member, so we can check the attributes later...
             var accessedType = member.ContainingType;
 
-            // Get the attributes
-            var friendAttribute = context.Compilation.GetTypeByMetadataName(AccessAttributeType);
-
             // Get the type that is containing this expression, or, the type where this is happening.
             if (context.ContainingSymbol?.ContainingType is not {} accessingType)
                 return;
 
             // Determine which type of access is happening here... Read, write or execute?
-            var accessAttempt = DetermineAccess(context, targetAccess, operation);
+            var accessAttempt = DetermineAccess(pureAttribute, targetAccess, operation);
 
             // Check whether this is a "self" access, including inheritors.
             var selfAccess = InheritsFromOrEquals(accessingType, accessedType);
@@ -194,7 +204,7 @@ bool CheckAttributeFriendship(AttributeData attribute, bool isMemberAttribute)
             }
         }
 
-        private static AccessPermissions DetermineAccess(OperationAnalysisContext context, IOperation operation, IOperation original)
+        private static AccessPermissions DetermineAccess(INamedTypeSymbol pureAttribute, IOperation operation, IOperation original)
         {
             switch (operation)
             {
@@ -205,8 +215,6 @@ private static AccessPermissions DetermineAccess(OperationAnalysisContext contex
 
                 case IInvocationOperation invoke:
                 {
-                    var pureAttribute = context.Compilation.GetTypeByMetadataName(PureAttributeType);
-
                     foreach (var attribute in invoke.TargetMethod.GetAttributes())
                     {
                         // Pure methods are treated as read accesses.
@@ -219,7 +227,7 @@ private static AccessPermissions DetermineAccess(OperationAnalysisContext contex
 
                 case IMemberReferenceOperation member:
                 {
-                    return DetermineAccess(context, member.Parent, operation);
+                    return DetermineAccess(pureAttribute, member.Parent, operation);
                 }
 
                 default:

Robust.Analyzers/ByRefEventAnalyzer.cs

@@ -56,6 +56,10 @@ public override void Initialize(AnalysisContext context)
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(compilationContext =>
         {
+            var byRefAttribute = compilationContext.Compilation.GetTypeByMetadataName(ByRefAttribute);
+            if (byRefAttribute == null)
+                return;
+
             var raiseMethods = compilationContext.Compilation
                 .GetTypeByMetadataName("Robust.Shared.GameObjects.EntitySystem")?
                 .GetMembers()
@@ -77,14 +81,15 @@ public override void Initialize(AnalysisContext context)
             var raiseMethodsArray = raiseMethods.ToArray();
 
             compilationContext.RegisterOperationAction(
-                ctx => CheckEventRaise(ctx, raiseMethodsArray),
+                ctx => CheckEventRaise(ctx, raiseMethodsArray, byRefAttribute),
                 OperationKind.Invocation);
         });
     }
 
     private static void CheckEventRaise(
         OperationAnalysisContext context,
-        IReadOnlyCollection<IMethodSymbol> raiseMethods)
+        IReadOnlyCollection<IMethodSymbol> raiseMethods,
+        INamedTypeSymbol byRefAttribute)
     {
         if (context.Operation is not IInvocationOperation operation)
             return;
@@ -126,10 +131,6 @@ private static void CheckEventRaise(
             return;
         }
 
-        var byRefAttribute = context.Compilation.GetTypeByMetadataName(ByRefAttribute);
-        if (byRefAttribute == null)
-            return;
-
         var isByRefEventType = eventParameter.Type
             .GetAttributes()
             .Any(attribute => attribute.AttributeClass?.Equals(byRefAttribute, Default) ?? false);

Robust.Analyzers/ExplicitInterfaceAnalyzer.cs

@@ -43,11 +43,53 @@ public override void Initialize(AnalysisContext context)
         {
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.None);
             context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.MethodDeclaration);
-            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.PropertyDeclaration);
+            context.RegisterCompilationStartAction(compilationContext =>
+            {
+                var attrSymbol = compilationContext.Compilation.GetTypeByMetadataName(RequiresExplicitImplementationAttributeMetadataName);
+                if (attrSymbol is null)
+                    return;
+
+                compilationContext.RegisterSymbolStartAction(symbolContext =>
+                {
+                    if (symbolContext.Symbol is not INamedTypeSymbol typeSymbol)
+                        return;
+
+                    var explicitInterfaceImplementations = GetExplicitInterfaceImplementations(typeSymbol, attrSymbol);
+                    if (explicitInterfaceImplementations.Count == 0)
+                        return;
+
+                    symbolContext.RegisterSyntaxNodeAction(
+                        nodeContext => AnalyzeNode(nodeContext, explicitInterfaceImplementations),
+                        SyntaxKind.MethodDeclaration);
+                    symbolContext.RegisterSyntaxNodeAction(
+                        nodeContext => AnalyzeNode(nodeContext, explicitInterfaceImplementations),
+                        SyntaxKind.PropertyDeclaration);
+                }, SymbolKind.NamedType);
+            });
         }
 
-        private void AnalyzeNode(SyntaxNodeAnalysisContext context)
+        private static HashSet<ISymbol> GetExplicitInterfaceImplementations(
+            INamedTypeSymbol typeSymbol,
+            INamedTypeSymbol attrSymbol)
+        {
+            var explicitInterfaceImplementations = new HashSet<ISymbol>(SymbolEqualityComparer.Default);
+
+            foreach (var interfaceSymbol in typeSymbol.AllInterfaces)
+            {
+                if (!interfaceSymbol.GetAttributes().Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attrSymbol)))
+                    continue;
+
+                foreach (var member in interfaceSymbol.GetMembers())
+                {
+                    if (typeSymbol.FindImplementationForInterfaceMember(member) is { } implementation)
+                        explicitInterfaceImplementations.Add(implementation);
+                }
+            }
+
+            return explicitInterfaceImplementations;
+        }
+
+        private void AnalyzeNode(SyntaxNodeAnalysisContext context, HashSet<ISymbol> explicitInterfaceImplementations)
         {
             ISymbol symbol;
             Location location;
@@ -72,15 +114,7 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context)
                     return;
             }
 
-            var attrSymbol = context.Compilation.GetTypeByMetadataName(RequiresExplicitImplementationAttributeMetadataName);
-
-            var isInterfaceMember = symbol?.ContainingType.AllInterfaces.Any(
-                i =>
-                    i.GetMembers().Any(m => SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(m)))
-                    && i.GetAttributes().Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attrSymbol))
-            ) ?? false;
-
-            if (isInterfaceMember)
+            if (symbol != null && explicitInterfaceImplementations.Contains(symbol))
             {
                 //we do not have an explicit interface specified. bad!
                 var diagnostic = Diagnostic.Create(

Robust.Analyzers/MustCallBaseAnalyzer.cs

@@ -31,18 +31,23 @@ public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
-        context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var attrSymbol = compilationContext.Compilation.GetTypeByMetadataName(Attribute);
+            if (attrSymbol is null)
+                return;
+
+            compilationContext.RegisterSymbolAction(
+                symbolContext => AnalyzeSymbol(symbolContext, attrSymbol),
+                SymbolKind.Method);
+        });
     }
 
-    private static void AnalyzeSymbol(SymbolAnalysisContext context)
+    private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbol attrSymbol)
     {
         if (context.Symbol is not IMethodSymbol { IsOverride: true } method)
             return;
 
-        var attrSymbol = context.Compilation.GetTypeByMetadataName(Attribute);
-        if (attrSymbol == null)
-            return;
-
         if (DoesMethodOverriderHaveAttribute(method, attrSymbol) is not { } data)
             return;
 

Robust.Analyzers/NoUncachedRegexAnalyzer.cs

@@ -37,10 +37,19 @@ public override void Initialize(AnalysisContext context)
     {
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
-        context.RegisterOperationAction(CheckInvocation, OperationKind.Invocation);
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var regexType = compilationContext.Compilation.GetTypeByMetadataName(RegexType);
+            if (regexType is null)
+                return;
+
+            compilationContext.RegisterOperationAction(
+                operationContext => CheckInvocation(operationContext, regexType),
+                OperationKind.Invocation);
+        });
     }
 
-    private static void CheckInvocation(OperationAnalysisContext context)
+    private static void CheckInvocation(OperationAnalysisContext context, INamedTypeSymbol regexType)
     {
         if (context.Operation is not IInvocationOperation invocation)
             return;
@@ -54,7 +63,6 @@ private static void CheckInvocation(OperationAnalysisContext context)
         if (targetMethod.ContainingType.Name != "Regex")
             return;
 
-        var regexType = context.Compilation.GetTypeByMetadataName(RegexType);
         if (!SymbolEqualityComparer.Default.Equals(regexType, targetMethod.ContainingType))
             return;
 

Robust.Analyzers/NotNullableFlagAnalyzer.cs

@@ -69,7 +69,18 @@ public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
         context.EnableConcurrentExecution();
-        context.RegisterOperationAction(CheckNotNullableFlag, OperationKind.Invocation);
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var attribute = compilationContext.Compilation.GetTypeByMetadataName(Attribute);
+            if (attribute is null)
+                return;
+
+            var @bool = compilationContext.Compilation.GetSpecialType(SpecialType.System_Boolean);
+
+            compilationContext.RegisterOperationAction(
+                operationContext => CheckNotNullableFlag(operationContext, attribute, @bool),
+                OperationKind.Invocation);
+        });
     }
 
     private bool TryGetTypeArgument(IMethodSymbol methodSymbol, string typeParamName, out ITypeSymbol typeArgument)
@@ -87,14 +98,11 @@ private bool TryGetTypeArgument(IMethodSymbol methodSymbol, string typeParamName
         return false;
     }
 
-    private void CheckNotNullableFlag(OperationAnalysisContext context)
+    private void CheckNotNullableFlag(OperationAnalysisContext context, INamedTypeSymbol attribute, INamedTypeSymbol @bool)
     {
         if (context.Operation is not IInvocationOperation invocationOperation || !invocationOperation.TargetMethod.IsGenericMethod)
             return;
 
-        var attribute = context.Compilation.GetTypeByMetadataName(Attribute);
-        var @bool = context.Compilation.GetSpecialType(SpecialType.System_Boolean);
-
         foreach (var argument in invocationOperation.Arguments)
         {
             if(argument.Parameter == null) continue;

Robust.Analyzers/PreferGenericVariantAnalyzer.cs

@@ -55,15 +55,32 @@ public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.ReportDiagnostics | GeneratedCodeAnalysisFlags.Analyze);
         context.EnableConcurrentExecution();
-        context.RegisterOperationAction(CheckForGenericVariant, OperationKind.Invocation);
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var preferGenericAttribute = compilationContext.Compilation.GetTypeByMetadataName(AttributeType);
+            if (preferGenericAttribute is null)
+                return;
+
+            var typeTypeSymbol = compilationContext.Compilation.GetTypeByMetadataName("System.Type");
+            if (typeTypeSymbol is null)
+                return;
+
+            var objType = compilationContext.Compilation.GetSpecialType(SpecialType.System_Object);
+
+            compilationContext.RegisterOperationAction(
+                operationContext => CheckForGenericVariant(operationContext, preferGenericAttribute, typeTypeSymbol, objType),
+                OperationKind.Invocation);
+        });
     }
 
-    private void CheckForGenericVariant(OperationAnalysisContext obj)
+    private void CheckForGenericVariant(
+        OperationAnalysisContext obj,
+        INamedTypeSymbol preferGenericAttribute,
+        INamedTypeSymbol typeTypeSymbol,
+        INamedTypeSymbol objType)
     {
         if(obj.Operation is not IInvocationOperation invocationOperation) return;
 
-        var preferGenericAttribute = obj.Compilation.GetTypeByMetadataName(AttributeType);
-
         string genericVariant = null;
         AttributeData foundAttribute = null;
         foreach (var attribute in invocationOperation.TargetMethod.GetAttributes())
@@ -79,7 +96,6 @@ private void CheckForGenericVariant(OperationAnalysisContext obj)
         if(genericVariant == null) return;
 
         var maxTypeParams = 0;
-        var typeTypeSymbol = obj.Compilation.GetTypeByMetadataName("System.Type");
         foreach (var parameter in invocationOperation.TargetMethod.Parameters)
         {
             if(!SymbolEqualityComparer.Default.Equals(parameter.Type, typeTypeSymbol)) break;
@@ -107,7 +123,6 @@ private void CheckForGenericVariant(OperationAnalysisContext obj)
 
             var typeParamCount = methodSymbol.TypeParameters.Length;
             var failedParamComparison = false;
-            var objType = obj.Compilation.GetSpecialType(SpecialType.System_Object);
             for (int i = 0; i < methodSymbol.Parameters.Length; i++)
             {
                 if (methodSymbol.Parameters[i].Type is ITypeParameterSymbol && SymbolEqualityComparer.Default.Equals(invocationOperation.TargetMethod.Parameters[i + typeParamCount].Type, objType))
@@ -152,10 +167,7 @@ private void CheckForGenericVariant(OperationAnalysisContext obj)
         obj.ReportDiagnostic(Diagnostic.Create(
             UseGenericVariantDescriptor,
             invocationOperation.Syntax.GetLocation(),
-            ImmutableDictionary.CreateRange(new Dictionary<string, string>()
-            {
-                {"typeOperands", string.Join(",", typeOperands)}
-            })));
+            ImmutableDictionary.Create<string, string>().Add("typeOperands", string.Join(",", typeOperands))));
     }
 }