Use extra generic type parameters and apply C#-specific knowledge to …

…all langs instead of using inheritance
dotnet · Nov 29, 2020 · 4365779 · 4365779
1 parent 5949b49
commit 4365779
Show file tree

Hide file tree

Showing 9 changed files with 54 additions and 56 deletions.
diff --git a/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems b/src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems
@@ -47,7 +47,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnreachableCode\CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnreachableCode\RemoveUnreachableCodeHelpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SimplifyBooleanExpression\CSharpSimplifyConditionalDiagnosticAnalyzer.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)SimplifyInterpolation\CSharpHelpers.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SimplifyInterpolation\CSharpSimplifyInterpolationDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseAutoProperty\CSharpUseAutoPropertyAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseCoalesceExpression\CSharpUseCoalesceExpressionDiagnosticAnalyzer.cs" />

diff --git a/src/Analyzers/CSharp/Analyzers/SimplifyInterpolation/CSharpHelpers.cs b/src/Analyzers/CSharp/Analyzers/SimplifyInterpolation/CSharpHelpers.cs
diff --git a/...s/CSharp/Analyzers/SimplifyInterpolation/CSharpSimplifyInterpolationDiagnosticAnalyzer.cs b/...s/CSharp/Analyzers/SimplifyInterpolation/CSharpSimplifyInterpolationDiagnosticAnalyzer.cs
@@ -4,7 +4,6 @@
 
 #nullable disable
 
-using Microsoft.CodeAnalysis.CSharp.Analyzers.SimplifyInterpolation;
 using Microsoft.CodeAnalysis.CSharp.EmbeddedLanguages.VirtualChars;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -17,14 +16,12 @@ namespace Microsoft.CodeAnalysis.CSharp.SimplifyInterpolation
 {
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal class CSharpSimplifyInterpolationDiagnosticAnalyzer : AbstractSimplifyInterpolationDiagnosticAnalyzer<
-        InterpolationSyntax, ExpressionSyntax>
+        InterpolationSyntax, ExpressionSyntax, ConditionalExpressionSyntax, ParenthesizedExpressionSyntax>
     {
         protected override IVirtualCharService GetVirtualCharService()
             => CSharpVirtualCharService.Instance;
 
         protected override ISyntaxFacts GetSyntaxFacts()
             => CSharpSyntaxFacts.Instance;
-
-        protected override Helpers GetHelpers() => new CSharpHelpers();
     }
 }
diff --git a/...zers/CSharp/CodeFixes/SimplifyInterpolation/CSharpSimplifyInterpolationCodeFixProvider.cs b/...zers/CSharp/CodeFixes/SimplifyInterpolation/CSharpSimplifyInterpolationCodeFixProvider.cs
@@ -8,7 +8,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.CSharp.Analyzers.SimplifyInterpolation;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.SimplifyInterpolation;
 
@@ -17,16 +16,15 @@ namespace Microsoft.CodeAnalysis.CSharp.SimplifyInterpolation
     [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
     internal class CSharpSimplifyInterpolationCodeFixProvider : AbstractSimplifyInterpolationCodeFixProvider<
         InterpolationSyntax, ExpressionSyntax, InterpolationAlignmentClauseSyntax,
-        InterpolationFormatClauseSyntax, InterpolatedStringExpressionSyntax>
+        InterpolationFormatClauseSyntax, InterpolatedStringExpressionSyntax,
+        ConditionalExpressionSyntax, ParenthesizedExpressionSyntax>
     {
         [ImportingConstructor]
         [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
         public CSharpSimplifyInterpolationCodeFixProvider()
         {
         }
 
-        protected override Helpers GetHelpers() => new CSharpHelpers();
-
         protected override InterpolationSyntax WithExpression(InterpolationSyntax interpolation, ExpressionSyntax expression)
             => interpolation.WithExpression(expression);
 

diff --git a/...s/Core/Analyzers/SimplifyInterpolation/AbstractSimplifyInterpolationDiagnosticAnalyzer.cs b/...s/Core/Analyzers/SimplifyInterpolation/AbstractSimplifyInterpolationDiagnosticAnalyzer.cs
@@ -15,9 +15,13 @@ namespace Microsoft.CodeAnalysis.SimplifyInterpolation
 {
     internal abstract class AbstractSimplifyInterpolationDiagnosticAnalyzer<
         TInterpolationSyntax,
-        TExpressionSyntax> : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+        TExpressionSyntax,
+        TConditionalExpressionSyntax,
+        TParenthesizedExpressionSyntax> : AbstractBuiltInCodeStyleDiagnosticAnalyzer
         where TInterpolationSyntax : SyntaxNode
         where TExpressionSyntax : SyntaxNode
+        where TConditionalExpressionSyntax : TExpressionSyntax
+        where TParenthesizedExpressionSyntax : TExpressionSyntax
     {
         protected AbstractSimplifyInterpolationDiagnosticAnalyzer()
            : base(IDEDiagnosticIds.SimplifyInterpolationId,
@@ -32,8 +36,6 @@ protected AbstractSimplifyInterpolationDiagnosticAnalyzer()
 
         protected abstract ISyntaxFacts GetSyntaxFacts();
 
-        protected virtual Helpers GetHelpers() => new();
-
         public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
             => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
@@ -60,7 +62,7 @@ private void AnalyzeInterpolation(OperationAnalysisContext context)
                 return;
             }
 
-            GetHelpers().UnwrapInterpolation<TInterpolationSyntax, TExpressionSyntax>(
+            Helpers.UnwrapInterpolation<TInterpolationSyntax, TExpressionSyntax, TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
                 GetVirtualCharService(), GetSyntaxFacts(), interpolation, out _, out var alignment, out _,
                 out var formatString, out var unnecessaryLocations);
 

diff --git a/src/Analyzers/Core/Analyzers/SimplifyInterpolation/Helpers.cs b/src/Analyzers/Core/Analyzers/SimplifyInterpolation/Helpers.cs
@@ -14,19 +14,28 @@
 
 namespace Microsoft.CodeAnalysis.SimplifyInterpolation
 {
-    internal class Helpers
+    internal static class Helpers
     {
-        protected virtual SyntaxNode GetPreservedInterpolationExpressionSyntax(IOperation operation)
+        private static SyntaxNode GetPreservedInterpolationExpressionSyntax<TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
+            IOperation operation)
+            where TConditionalExpressionSyntax : SyntaxNode
+            where TParenthesizedExpressionSyntax : SyntaxNode
         {
-            return operation.Syntax;
+            return operation.Syntax switch
+            {
+                TConditionalExpressionSyntax { Parent: TParenthesizedExpressionSyntax parent } => parent,
+                var syntax => syntax,
+            };
         }
 
-        public void UnwrapInterpolation<TInterpolationSyntax, TExpressionSyntax>(
+        public static void UnwrapInterpolation<TInterpolationSyntax, TExpressionSyntax, TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
             IVirtualCharService virtualCharService, ISyntaxFacts syntaxFacts, IInterpolationOperation interpolation,
             out TExpressionSyntax? unwrapped, out TExpressionSyntax? alignment, out bool negate,
             out string? formatString, out ImmutableArray<Location> unnecessaryLocations)
-                where TInterpolationSyntax : SyntaxNode
-                where TExpressionSyntax : SyntaxNode
+            where TInterpolationSyntax : SyntaxNode
+            where TExpressionSyntax : SyntaxNode
+            where TConditionalExpressionSyntax : TExpressionSyntax
+            where TParenthesizedExpressionSyntax : TExpressionSyntax
         {
             alignment = null;
             negate = false;
@@ -37,15 +46,17 @@ public void UnwrapInterpolation<TInterpolationSyntax, TExpressionSyntax>(
             var expression = Unwrap(interpolation.Expression);
             if (interpolation.Alignment == null)
             {
-                UnwrapAlignmentPadding(expression, out expression, out alignment, out negate, unnecessarySpans);
+                UnwrapAlignmentPadding<TExpressionSyntax, TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
+                    expression, out expression, out alignment, out negate, unnecessarySpans);
             }
 
             if (interpolation.FormatString == null)
             {
-                UnwrapFormatString(virtualCharService, syntaxFacts, expression, out expression, out formatString, unnecessarySpans);
+                UnwrapFormatString<TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
+                    virtualCharService, syntaxFacts, expression, out expression, out formatString, unnecessarySpans);
             }
 
-            unwrapped = GetPreservedInterpolationExpressionSyntax(expression) as TExpressionSyntax;
+            unwrapped = GetPreservedInterpolationExpressionSyntax<TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(expression) as TExpressionSyntax;
 
             unnecessaryLocations =
                 unnecessarySpans.OrderBy(t => t.Start)
@@ -70,9 +81,11 @@ private static IOperation Unwrap(IOperation expression)
             }
         }
 
-        private void UnwrapFormatString(
+        private static void UnwrapFormatString<TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
             IVirtualCharService virtualCharService, ISyntaxFacts syntaxFacts, IOperation expression, out IOperation unwrapped,
             out string? formatString, List<TextSpan> unnecessarySpans)
+            where TConditionalExpressionSyntax : SyntaxNode
+            where TParenthesizedExpressionSyntax : SyntaxNode
         {
             if (expression is IInvocationOperation { TargetMethod: { Name: nameof(ToString) } } invocation &&
                 HasNonImplicitInstance(invocation) &&
@@ -87,8 +100,9 @@ private void UnwrapFormatString(
                     unwrapped = invocation.Instance;
                     formatString = value;
 
+                    var unwrappedSyntax = GetPreservedInterpolationExpressionSyntax<TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(unwrapped);
                     unnecessarySpans.AddRange(invocation.Syntax.Span
-                        .Subtract(GetPreservedInterpolationExpressionSyntax(invocation.Instance).FullSpan)
+                        .Subtract(unwrappedSyntax.FullSpan)
                         .Subtract(GetSpanWithinLiteralQuotes(virtualCharService, literal.Syntax.GetFirstToken())));
                     return;
                 }
@@ -107,8 +121,9 @@ private void UnwrapFormatString(
                     unwrapped = invocation.Instance;
                     formatString = "";
 
+                    var unwrappedSyntax = GetPreservedInterpolationExpressionSyntax<TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(unwrapped);
                     unnecessarySpans.AddRange(invocation.Syntax.Span
-                        .Subtract(GetPreservedInterpolationExpressionSyntax(invocation.Instance).FullSpan));
+                        .Subtract(unwrappedSyntax.FullSpan));
                     return;
                 }
             }
@@ -125,10 +140,12 @@ private static TextSpan GetSpanWithinLiteralQuotes(IVirtualCharService virtualCh
                 : TextSpan.FromBounds(sequence.First().Span.Start, sequence.Last().Span.End);
         }
 
-        private void UnwrapAlignmentPadding<TExpressionSyntax>(
+        private static void UnwrapAlignmentPadding<TExpressionSyntax, TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
             IOperation expression, out IOperation unwrapped,
             out TExpressionSyntax? alignment, out bool negate, List<TextSpan> unnecessarySpans)
             where TExpressionSyntax : SyntaxNode
+            where TConditionalExpressionSyntax : TExpressionSyntax
+            where TParenthesizedExpressionSyntax : TExpressionSyntax
         {
             if (expression is IInvocationOperation invocation &&
                 HasNonImplicitInstance(invocation))
@@ -151,8 +168,9 @@ private void UnwrapAlignmentPadding<TExpressionSyntax>(
                                 alignment = alignmentSyntax as TExpressionSyntax;
                                 negate = targetName == nameof(string.PadRight);
 
+                                var unwrappedSyntax = GetPreservedInterpolationExpressionSyntax<TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(unwrapped);
                                 unnecessarySpans.AddRange(invocation.Syntax.Span
-                                    .Subtract(GetPreservedInterpolationExpressionSyntax(invocation.Instance).FullSpan)
+                                    .Subtract(unwrappedSyntax.FullSpan)
                                     .Subtract(alignmentSyntax.FullSpan));
                                 return;
                             }

diff --git a/...zers/Core/CodeFixes/SimplifyInterpolation/AbstractSimplifyInterpolationCodeFixProvider.cs b/...zers/Core/CodeFixes/SimplifyInterpolation/AbstractSimplifyInterpolationCodeFixProvider.cs
@@ -23,20 +23,22 @@ internal abstract class AbstractSimplifyInterpolationCodeFixProvider<
         TExpressionSyntax,
         TInterpolationAlignmentClause,
         TInterpolationFormatClause,
-        TInterpolatedStringExpressionSyntax> : SyntaxEditorBasedCodeFixProvider
+        TInterpolatedStringExpressionSyntax,
+        TConditionalExpressionSyntax,
+        TParenthesizedExpressionSyntax> : SyntaxEditorBasedCodeFixProvider
         where TInterpolationSyntax : SyntaxNode
         where TExpressionSyntax : SyntaxNode
         where TInterpolationAlignmentClause : SyntaxNode
         where TInterpolationFormatClause : SyntaxNode
         where TInterpolatedStringExpressionSyntax : TExpressionSyntax
+        where TConditionalExpressionSyntax : TExpressionSyntax
+        where TParenthesizedExpressionSyntax : TExpressionSyntax
     {
         public override ImmutableArray<string> FixableDiagnosticIds { get; } =
             ImmutableArray.Create(IDEDiagnosticIds.SimplifyInterpolationId);
 
         internal override CodeFixCategory CodeFixCategory => CodeFixCategory.CodeStyle;
 
-        protected virtual Helpers GetHelpers() => new();
-
         protected abstract TInterpolationSyntax WithExpression(TInterpolationSyntax interpolation, TExpressionSyntax expression);
         protected abstract TInterpolationSyntax WithAlignmentClause(TInterpolationSyntax interpolation, TInterpolationAlignmentClause alignmentClause);
         protected abstract TInterpolationSyntax WithFormatClause(TInterpolationSyntax interpolation, TInterpolationFormatClause? formatClause);
@@ -57,16 +59,14 @@ protected override async Task FixAllAsync(
             var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var generator = editor.Generator;
             var generatorInternal = document.GetRequiredLanguageService<SyntaxGeneratorInternal>();
-            var helpers = GetHelpers();
-
             foreach (var diagnostic in diagnostics)
             {
                 var loc = diagnostic.AdditionalLocations[0];
                 var interpolation = semanticModel.GetOperation(loc.FindNode(getInnermostNodeForTie: true, cancellationToken), cancellationToken) as IInterpolationOperation;
                 if (interpolation?.Syntax is TInterpolationSyntax interpolationSyntax &&
                     interpolationSyntax.Parent is TInterpolatedStringExpressionSyntax interpolatedString)
                 {
-                    helpers.UnwrapInterpolation<TInterpolationSyntax, TExpressionSyntax>(
+                    Helpers.UnwrapInterpolation<TInterpolationSyntax, TExpressionSyntax, TConditionalExpressionSyntax, TParenthesizedExpressionSyntax>(
                         document.GetRequiredLanguageService<IVirtualCharLanguageService>(),
                         document.GetRequiredLanguageService<ISyntaxFactsService>(), interpolation, out var unwrapped,
                         out var alignment, out var negate, out var formatString, out _);

diff --git a/...sic/Analyzers/SimplifyInterpolation/VisualBasicSimplifyInterpolationDiagnosticAnalyzer.vb b/...sic/Analyzers/SimplifyInterpolation/VisualBasicSimplifyInterpolationDiagnosticAnalyzer.vb
@@ -13,7 +13,11 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
 Namespace Microsoft.CodeAnalysis.VisualBasic.SimplifyInterpolation
     <DiagnosticAnalyzer(LanguageNames.VisualBasic)>
     Friend Class VisualBasicSimplifyInterpolationDiagnosticAnalyzer
-        Inherits AbstractSimplifyInterpolationDiagnosticAnalyzer(Of InterpolationSyntax, ExpressionSyntax)
+        Inherits AbstractSimplifyInterpolationDiagnosticAnalyzer(Of
+            InterpolationSyntax,
+            ExpressionSyntax,
+            TernaryConditionalExpressionSyntax,
+            ParenthesizedExpressionSyntax)
 
         Protected Overrides Function GetVirtualCharService() As IVirtualCharService
             Return VisualBasicVirtualCharService.Instance

diff --git a/...lBasic/CodeFixes/SimplifyInterpolation/VisualBasicSimplifyInterpolationCodeFixProvider.vb b/...lBasic/CodeFixes/SimplifyInterpolation/VisualBasicSimplifyInterpolationCodeFixProvider.vb
@@ -13,7 +13,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.SimplifyInterpolation
     Friend Class VisualBasicSimplifyInterpolationCodeFixProvider
         Inherits AbstractSimplifyInterpolationCodeFixProvider(Of
             InterpolationSyntax, ExpressionSyntax, InterpolationAlignmentClauseSyntax,
-            InterpolationFormatClauseSyntax, InterpolatedStringExpressionSyntax)
+            InterpolationFormatClauseSyntax, InterpolatedStringExpressionSyntax,
+            TernaryConditionalExpressionSyntax, ParenthesizedExpressionSyntax)
 
         <ImportingConstructor>
         <SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification:="Used in test code: https://github.com/dotnet/roslyn/issues/42814")>