Simplify tuple support checks

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers/Helpers/LanguageFeatureHelpers.cs

@@ -5,6 +5,7 @@
 
 namespace StyleCop.Analyzers.Helpers
 {
+    using System.Diagnostics.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Lightup;
@@ -14,6 +15,17 @@ namespace StyleCop.Analyzers.Helpers
     /// </summary>
     internal static class LanguageFeatureHelpers
     {
+        /// <summary>
+        /// Checks if the tuple language feature is supported.
+        /// </summary>
+        /// <param name="context">The analysis context that will be checked.</param>
+        /// <returns>True if tuples are supported by the compiler.</returns>
+        [SuppressMessage("MicrosoftCodeAnalysisPerformance", "RS1012:Start action has no registered actions", Justification = "This is not a start action method.")]
+        internal static bool SupportsTuples(this CompilationStartAnalysisContext context)
+        {
+            return context.Compilation is CSharpCompilation { LanguageVersion: >= LanguageVersionEx.CSharp7 };
+        }
+
         /// <summary>
         /// Checks if the tuple language feature is supported.
         /// </summary>

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1141UseTupleSyntax.cs

@@ -50,6 +50,14 @@ public override void Initialize(AnalysisContext context)
             context.EnableConcurrentExecution();
 
             context.RegisterCompilationStartAction(CompilationStartAction);
+        }
+
+        private static void HandleCompilationStart(CompilationStartAnalysisContext context)
+        {
+            if (!context.SupportsTuples())
+            {
+                return;
+            }
 
             context.RegisterSyntaxNodeAction(MethodDeclarationAction, SyntaxKind.MethodDeclaration);
             context.RegisterSyntaxNodeAction(ConversionOperatorAction, SyntaxKind.ConversionOperatorDeclaration);
@@ -59,10 +67,7 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterSyntaxNodeAction(DelegateDeclarationAction, SyntaxKind.DelegateDeclaration);
             context.RegisterSyntaxNodeAction(LambdaExpressionAction, SyntaxKinds.LambdaExpression);
-        }
 
-        private static void HandleCompilationStart(CompilationStartAnalysisContext context)
-        {
             var expressionType = context.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
 
             context.RegisterSyntaxNodeAction(context => HandleObjectCreationExpression(context, expressionType), SyntaxKind.ObjectCreationExpression);
@@ -75,11 +80,6 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
 
         private static void HandleMethodDeclaration(SyntaxNodeAnalysisContext context)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var methodDeclaration = (MethodDeclarationSyntax)context.Node;
 
             CheckType(context, expressionType: null, methodDeclaration.ReturnType);
@@ -88,11 +88,6 @@ private static void HandleMethodDeclaration(SyntaxNodeAnalysisContext context)
 
         private static void HandleConversionOperator(SyntaxNodeAnalysisContext context)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)context.Node;
 
             CheckType(context, expressionType: null, conversionOperatorDeclaration.Type);
@@ -101,33 +96,18 @@ private static void HandleConversionOperator(SyntaxNodeAnalysisContext context)
 
         private static void HandleBasePropertyDeclaration(SyntaxNodeAnalysisContext context)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var propertyDeclaration = (BasePropertyDeclarationSyntax)context.Node;
             CheckType(context, expressionType: null, propertyDeclaration.Type);
         }
 
         private static void HandleFieldDeclaration(SyntaxNodeAnalysisContext context)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var fieldDeclaration = (BaseFieldDeclarationSyntax)context.Node;
             CheckType(context, expressionType: null, fieldDeclaration.Declaration.Type);
         }
 
         private static void HandleLambdaExpression(SyntaxNodeAnalysisContext context)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var lambdaExpression = (LambdaExpressionSyntax)context.Node;
             if (lambdaExpression is ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpression)
             {
@@ -137,22 +117,12 @@ private static void HandleLambdaExpression(SyntaxNodeAnalysisContext context)
 
         private static void HandleObjectCreationExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol expressionType)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var objectCreationExpression = (ObjectCreationExpressionSyntax)context.Node;
             CheckType(context, expressionType, objectCreationExpression.Type, objectCreationExpression.GetLocation());
         }
 
         private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol expressionType)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var invocationExpression = (InvocationExpressionSyntax)context.Node;
             if (invocationExpression.ArgumentList.Arguments.Count < 2)
             {
@@ -181,34 +151,19 @@ private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context
 
         private static void HandleDefaultExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol expressionType)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var defaultExpression = (DefaultExpressionSyntax)context.Node;
             CheckType(context, expressionType, defaultExpression.Type);
         }
 
         private static void HandleDelegateDeclaration(SyntaxNodeAnalysisContext context)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var delegateDeclaration = (DelegateDeclarationSyntax)context.Node;
             CheckType(context, expressionType: null, delegateDeclaration.ReturnType);
             CheckParameterList(context, delegateDeclaration.ParameterList);
         }
 
         private static void HandleCastExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol expressionType)
         {
-            if (!context.SupportsTuples())
-            {
-                return;
-            }
-
             var castExpression = (CastExpressionSyntax)context.Node;
             CheckType(context, expressionType, castExpression.Type);
         }