Replace generic function on IInspectionResult with additional generic interface IWithInspectionResultProperties<T>

MDoerner · MDoerner · commit b4ae264db13c · 2020-02-12T19:10:04.000+01:00
This change makes the structure look a bit cleaner.
Unfortunately, the new interface cannot extend the old one because the corresponding generic inspection result classes have to inherit from the non-generic ones.
diff --git a/Rubberduck.CodeAnalysis/Inspections/Abstract/InspectionResultBase.cs b/Rubberduck.CodeAnalysis/Inspections/Abstract/InspectionResultBase.cs
@@ -37,8 +37,6 @@ protected InspectionResultBase(IInspection inspection,
         public Declaration Target { get; }
         public ICollection<string> DisabledQuickFixes { get; }
 
-        public virtual T Properties<T>() => default;
-
         public virtual bool ChangesInvalidateResult(ICollection<QualifiedModuleName> modifiedModules)
         {
             return modifiedModules.Contains(QualifiedName) 
diff --git a/Rubberduck.CodeAnalysis/Inspections/Results/DeclarationInspectionResult.cs b/Rubberduck.CodeAnalysis/Inspections/Results/DeclarationInspectionResult.cs
@@ -44,15 +44,13 @@ public override bool ChangesInvalidateResult(ICollection<QualifiedModuleName> mo
         }
     }
 
-    public class DeclarationInspectionResult<TProperties> : DeclarationInspectionResult
+    public class DeclarationInspectionResult<T> : DeclarationInspectionResult, IWithInspectionResultProperties<T>
     {
-        private readonly TProperties _properties;
-
         public DeclarationInspectionResult(
             IInspection inspection, 
             string description, 
             Declaration target,
-            TProperties properties, 
+            T properties, 
             QualifiedContext context = null,
             ICollection<string> disabledQuickFixes = null) :
             base(
@@ -62,17 +60,9 @@ public DeclarationInspectionResult(
                 context,
                 disabledQuickFixes)
         {
-            _properties = properties;
+            Properties = properties;
         }
 
-        public override T Properties<T>()
-        {
-            if (_properties is T properties)
-            {
-                return properties;
-            }
-
-            return base.Properties<T>();
-        }
+        public T Properties { get; }
     }
 }
diff --git a/Rubberduck.CodeAnalysis/Inspections/Results/IdentifierReferenceInspectionResult.cs b/Rubberduck.CodeAnalysis/Inspections/Results/IdentifierReferenceInspectionResult.cs
@@ -44,16 +44,14 @@ public override bool ChangesInvalidateResult(ICollection<QualifiedModuleName> mo
         }
     }
 
-    public class IdentifierReferenceInspectionResult<TProperties> : IdentifierReferenceInspectionResult
+    public class IdentifierReferenceInspectionResult<T> : IdentifierReferenceInspectionResult, IWithInspectionResultProperties<T>
     {
-        private readonly TProperties _properties;
-
         public IdentifierReferenceInspectionResult(
             IInspection inspection, 
             string description, 
             IDeclarationFinderProvider declarationFinderProvider, 
             IdentifierReference reference, 
-            TProperties properties,
+            T properties,
             ICollection<string> disabledQuickFixes = null) 
             : base(
                 inspection,
@@ -62,17 +60,9 @@ public IdentifierReferenceInspectionResult(
                 reference,
                 disabledQuickFixes)
         {
-            _properties = properties;
+            Properties = properties;
         }
 
-        public override T Properties<T>()
-        {
-            if (_properties is T properties)
-            {
-                return properties;
-            }
-
-            return base.Properties<T>();
-        }
+        public T Properties { get; }
     }
 }
diff --git a/Rubberduck.CodeAnalysis/Inspections/Results/QualifiedContextInspectionResult.cs b/Rubberduck.CodeAnalysis/Inspections/Results/QualifiedContextInspectionResult.cs
@@ -24,33 +24,23 @@ public QualifiedContextInspectionResult(
         {}
     }
 
-    public class QualifiedContextInspectionResult<TProperties> : QualifiedContextInspectionResult
+    public class QualifiedContextInspectionResult<T> : QualifiedContextInspectionResult, IWithInspectionResultProperties<T>
     {
-        private readonly TProperties _properties;
-
         public QualifiedContextInspectionResult(
             IInspection inspection, 
             string description, 
             QualifiedContext context,
-            TProperties properties,
+            T properties,
             ICollection<string> disabledQuickFixes = null) :
             base(
                 inspection,
                 description,
                 context,
                 disabledQuickFixes)
         {
-            _properties = properties;
+            Properties = properties;
         }
 
-        public override T Properties<T>()
-        {
-            if (_properties is T properties)
-            {
-                return properties;
-            }
-
-            return base.Properties<T>();
-        }
+        public T Properties { get; }
     }
 }
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AccessSheetUsingCodeNameQuickFix.cs
@@ -48,7 +48,7 @@ public AccessSheetUsingCodeNameQuickFix(IDeclarationFinderProvider declarationFi
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            var referenceResult = (IdentifierReferenceInspectionResult)result;
+            var referenceResult = (IdentifierReferenceInspectionResult<string>)result;
 
             var rewriter = rewriteSession.CheckOutModuleRewriter(referenceResult.QualifiedName);
 
@@ -62,7 +62,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio
                 var indexExprContext = referenceResult.Context.Parent.Parent as VBAParser.IndexExprContext ??
                                        referenceResult.Context.Parent as VBAParser.IndexExprContext;
 
-                var codeName = referenceResult.Properties<string>();
+                var codeName = referenceResult.Properties;
                 rewriter.Replace(indexExprContext, codeName);
             }
             else
@@ -98,7 +98,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio
 
                 foreach (var reference in sheetDeclaration.References)
                 {
-                    var codeName = referenceResult.Properties<string>();
+                    var codeName = referenceResult.Properties;
                     rewriter.Replace(reference.Context, codeName);
                 }
 
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AddAttributeAnnotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AddAttributeAnnotationQuickFix.cs
@@ -60,8 +60,13 @@ public AddAttributeAnnotationQuickFix(IAnnotationUpdater annotationUpdater, IAtt
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
+            if (!(result is IWithInspectionResultProperties<(string attributeName, IReadOnlyList<string> AttributeValues)> resultProperties))
+            {
+                return;
+            }
+
             var declaration = result.Target;
-            var (attributeName, attributeValues) = result.Properties<(string attributeName, IReadOnlyList<string> AttributeValues)>();
+            var (attributeName, attributeValues) = resultProperties.Properties;
             var (annotationType, annotationValues) = declaration.DeclarationType.HasFlag(DeclarationType.Module)
                 ? _attributeAnnotationProvider.ModuleAttributeAnnotation(attributeName, attributeValues)
                 : _attributeAnnotationProvider.MemberAttributeAnnotation(AttributeBaseName(attributeName, declaration), attributeValues);
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AddMissingAttributeQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AddMissingAttributeQuickFix.cs
@@ -54,8 +54,13 @@ public AddMissingAttributeQuickFix(IAttributesUpdater attributesUpdater)
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
+            if (!(result is IWithInspectionResultProperties<IParseTreeAnnotation> resultProperties))
+            {
+                return;
+            }
+
             var declaration = result.Target;
-            var annotationInstance = result.Properties<IParseTreeAnnotation>();
+            var annotationInstance = resultProperties.Properties;
             if (!(annotationInstance.Annotation is IAttributeAnnotation annotation))
             {
                 return;
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AdjustAttributeAnnotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AdjustAttributeAnnotationQuickFix.cs
@@ -59,8 +59,13 @@ public AdjustAttributeAnnotationQuickFix(IAnnotationUpdater annotationUpdater, I
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
+            if (!(result is IWithInspectionResultProperties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)> resultProperties))
+            {
+                return;
+            }
+
             var declaration = result.Target;
-            var (oldParseTreeAnnotation, attributeBaseName, attributeValues) = result.Properties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)>();
+            var (oldParseTreeAnnotation, attributeBaseName, attributeValues) = resultProperties.Properties;
 
             if (declaration.DeclarationType.HasFlag(DeclarationType.Module))
             {
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/AdjustAttributeValuesQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/AdjustAttributeValuesQuickFix.cs
@@ -61,8 +61,13 @@ public AdjustAttributeValuesQuickFix(IAttributesUpdater attributesUpdater)
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
+            if (!(result is IWithInspectionResultProperties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)> resultProperties))
+            {
+                return;
+            }
+
             var declaration = result.Target;
-            var (parseTreeAnnotation, attributeBaseName, attributeValues) = result.Properties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)>();
+            var (parseTreeAnnotation, attributeBaseName, attributeValues) = resultProperties.Properties;
 
             var attributeName = declaration.DeclarationType.HasFlag(DeclarationType.Module)
                 ? attributeBaseName
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/ExpandDefaultMemberQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/ExpandDefaultMemberQuickFix.cs
@@ -76,7 +76,12 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio
 
             if (result.Inspection is SuspiciousLetAssignmentInspection)
             {
-                var rhsReference = result.Properties<IdentifierReference>();
+                if (!(result is IWithInspectionResultProperties<IdentifierReference> resultProperties))
+                {
+                    return;
+                }
+
+                var rhsReference = resultProperties.Properties;
                 var rhsLExpressionContext = rhsReference.Context;
                 var rhsSelection = rhsReference.QualifiedSelection;
                 InsertDefaultMember(rhsLExpressionContext, rhsSelection, finder, rewriter);
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/IsMissingOnInappropriateArgumentQuickFix.cs
@@ -51,7 +51,12 @@ public IsMissingOnInappropriateArgumentQuickFix(IDeclarationFinderProvider decla
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            var parameter = result.Properties<ParameterDeclaration>();
+            if (!(result is IWithInspectionResultProperties<ParameterDeclaration> resultProperties))
+            {
+                return;
+            }
+
+            var parameter = resultProperties.Properties;
             if (parameter == null)
             {
                 Logger.Trace($"Properties for IsMissingOnInappropriateArgumentQuickFix was null.");
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveAnnotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveAnnotationQuickFix.cs
@@ -49,7 +49,12 @@ public RemoveAnnotationQuickFix(IAnnotationUpdater annotationUpdater)
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            _annotationUpdater.RemoveAnnotation(rewriteSession, result.Properties<IParseTreeAnnotation>());
+            if (!(result is IWithInspectionResultProperties<IParseTreeAnnotation> resultProperties))
+            {
+                return;
+            }
+
+            _annotationUpdater.RemoveAnnotation(rewriteSession, resultProperties.Properties);
         }
 
         public override string Description(IInspectionResult result) => Resources.Inspections.QuickFixes.RemoveAnnotationQuickFix;
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveAttributeQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveAttributeQuickFix.cs
@@ -51,8 +51,13 @@ public RemoveAttributeQuickFix(IAttributesUpdater attributesUpdater)
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
+            if (!(result is IWithInspectionResultProperties<(string AttributeName, IReadOnlyList<string> AttributeValues)> resultProperties))
+            {
+                return;
+            }
+
             var declaration = result.Target;
-            var (attributeBaseName, attributeValues) = result.Properties<(string AttributeName, IReadOnlyList<string> AttributeValues)>();
+            var (attributeBaseName, attributeValues) = resultProperties.Properties;
 
             var attributeName = declaration.DeclarationType.HasFlag(DeclarationType.Module)
                 ? attributeBaseName
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RemoveDuplicatedAnnotationQuickFix.cs
@@ -48,7 +48,12 @@ public RemoveDuplicatedAnnotationQuickFix(IAnnotationUpdater annotationUpdater)
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
-            var resultAnnotation = result.Properties<IAnnotation>();
+            if (!(result is IWithInspectionResultProperties<IAnnotation> resultProperties))
+            {
+                return;
+            }
+
+            var resultAnnotation = resultProperties.Properties;
             var duplicateAnnotations = result.Target.Annotations
                 .Where(pta => pta.Annotation == resultAnnotation)
                 .OrderBy(annotation => annotation.AnnotatedLine)
diff --git a/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs b/Rubberduck.CodeAnalysis/QuickFixes/RestoreErrorHandlingQuickFix.cs
@@ -55,6 +55,11 @@ public RestoreErrorHandlingQuickFix()
 
         public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)
         {
+            if (!(result is IWithInspectionResultProperties<List<ParserRuleContext>> resultProperties))
+            {
+                return;
+            }
+
             var exitStatement = "Exit ";
             VBAParser.BlockContext block;
             var bodyElementContext = result.Context.GetAncestor<VBAParser.ModuleBodyElementContext>();
@@ -89,7 +94,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio
             var context = (VBAParser.OnErrorStmtContext)result.Context;
             var labels = bodyElementContext.GetDescendents<VBAParser.IdentifierStatementLabelContext>().ToArray();
             var maximumExistingLabelIndex = GetMaximumExistingLabelIndex(labels);
-            var unhandledContexts = result.Properties<List<ParserRuleContext>>();
+            var unhandledContexts = resultProperties.Properties;
             var offset = unhandledContexts.IndexOf(result.Context);
             var labelIndex = maximumExistingLabelIndex + offset;
 
diff --git a/Rubberduck.Parsing/Inspections/Abstract/IInspectionResult.cs b/Rubberduck.Parsing/Inspections/Abstract/IInspectionResult.cs
@@ -15,7 +15,11 @@ public interface IInspectionResult : IComparable<IInspectionResult>, IComparable
         Declaration Target { get; }
         ParserRuleContext Context { get; }
         ICollection<string> DisabledQuickFixes { get; }
-        T Properties<T>();
         bool ChangesInvalidateResult(ICollection<QualifiedModuleName> modifiedModules);
     }
+
+    public interface IWithInspectionResultProperties<T>
+    {
+        T Properties { get; }
+    }
 }
diff --git a/RubberduckTests/Inspections/AttributeValueOutOfSyncInspectionTests.cs b/RubberduckTests/Inspections/AttributeValueOutOfSyncInspectionTests.cs
@@ -218,12 +218,19 @@ Public Sub Foo()
             var inspectionResults = InspectionResults(inputCode);
             var inspectionResult = inspectionResults.First();
 
-            var (pta, attributeName, attributeValues) = inspectionResult.Properties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)>();
-
-            Assert.IsInstanceOf<MemberAttributeAnnotation>(pta.Annotation);
-            Assert.AreEqual("VB_UserMemId", attributeName);
-            Assert.AreEqual("-4", ((IAttributeAnnotation)pta.Annotation).AttributeValues(pta)[0]);
-            Assert.AreEqual("40", attributeValues[0]);
+            if (inspectionResult is IWithInspectionResultProperties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)> resultProperties)
+            {
+                var (pta, attributeName, attributeValues) = resultProperties.Properties;
+
+                Assert.IsInstanceOf<MemberAttributeAnnotation>(pta.Annotation);
+                Assert.AreEqual("VB_UserMemId", attributeName);
+                Assert.AreEqual("-4", ((IAttributeAnnotation)pta.Annotation).AttributeValues(pta)[0]);
+                Assert.AreEqual("40", attributeValues[0]);
+            }
+            else
+            {
+                Assert.Fail("Result is missing expected properties.");
+            }
         }
 
         private IEnumerable<IInspectionResult> InspectionResults(string inputCode, ComponentType componentType = ComponentType.StandardModule)
diff --git a/RubberduckTests/Inspections/MissingMemberAnnotationInspectionTests.cs b/RubberduckTests/Inspections/MissingMemberAnnotationInspectionTests.cs
@@ -177,11 +177,18 @@ Public Sub Foo()
             var expectedAttributeValues = new List<string>{"-4"};
 
             var inspectionResult = inspectionResults.Single();
-            var (actualAttributeBaseName, actualAttributeValues) = inspectionResult.Properties<(string AttributeName, IReadOnlyList<string> AttributeValues)>();
-
-            Assert.AreEqual(expectedAttributeName, actualAttributeBaseName);
-            Assert.AreEqual(expectedAttributeValues.Count, actualAttributeValues.Count);
-            Assert.AreEqual(expectedAttributeValues[0], actualAttributeValues[0]);
+            if (inspectionResult is IWithInspectionResultProperties<(string AttributeName, IReadOnlyList<string>AttributeValues)> resultProperties)
+            {
+                var (actualAttributeBaseName, actualAttributeValues) = resultProperties.Properties;
+
+                Assert.AreEqual(expectedAttributeName, actualAttributeBaseName);
+                Assert.AreEqual(expectedAttributeValues.Count, actualAttributeValues.Count);
+                Assert.AreEqual(expectedAttributeValues[0], actualAttributeValues[0]);
+            }
+            else
+            {
+                Assert.Fail("Result is missing expected properties.");
+            }
         }
 
         private IEnumerable<IInspectionResult> InspectionResults(string inputCode, ComponentType componentType = ComponentType.StandardModule)
diff --git a/RubberduckTests/Inspections/MissingModuleAnnotationInspectionTests.cs b/RubberduckTests/Inspections/MissingModuleAnnotationInspectionTests.cs
@@ -425,11 +425,19 @@ Public Sub Foo()
             var expectedAttributeValues = new List<string> { "\"Desc\"" };
 
             var inspectionResult = inspectionResults.Single();
-            var (actualAttributeBaseName, actualAttributeValues) = inspectionResult.Properties<(string AttributeName, IReadOnlyList<string> AttributeValues)>();
 
-            Assert.AreEqual(expectedAttributeName, actualAttributeBaseName);
-            Assert.AreEqual(expectedAttributeValues.Count, actualAttributeValues.Count);
-            Assert.AreEqual(expectedAttributeValues[0], actualAttributeValues[0]);
+            if (inspectionResult is IWithInspectionResultProperties<(string AttributeName, IReadOnlyList<string> AttributeValues)> resultProperties)
+            {
+                var (actualAttributeBaseName, actualAttributeValues) = resultProperties.Properties;
+
+                Assert.AreEqual(expectedAttributeName, actualAttributeBaseName);
+                Assert.AreEqual(expectedAttributeValues.Count, actualAttributeValues.Count);
+                Assert.AreEqual(expectedAttributeValues[0], actualAttributeValues[0]);
+            }
+            else
+            {
+                Assert.Fail("Result is missing expected properties.");
+            }
         }
 
         private IEnumerable<IInspectionResult> InspectionResults(string inputCode, ComponentType componentType = ComponentType.StandardModule)
diff --git a/RubberduckTests/Inspections/SuspiciousLetAssignmentInspectionTests.cs b/RubberduckTests/Inspections/SuspiciousLetAssignmentInspectionTests.cs
diff --git a/RubberduckTests/QuickFixes/RemoveDuplicatedAnnotationQuickFixTests.cs b/RubberduckTests/QuickFixes/RemoveDuplicatedAnnotationQuickFixTests.cs

Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,6 @@ protected InspectionResultBase(IInspection inspection,`
`37`	`37`	`public Declaration Target { get; }`
`38`	`38`	`public ICollection<string> DisabledQuickFixes { get; }`
`39`	`39`
`40`		`- public virtual T Properties<T>() => default;`
`41`		`-`
`42`	`40`	`public virtual bool ChangesInvalidateResult(ICollection<QualifiedModuleName> modifiedModules)`
`43`	`41`	`{`
`44`	`42`	`return modifiedModules.Contains(QualifiedName)`
Original file line number	Diff line number	Diff line change
`@@ -44,15 +44,13 @@ public override bool ChangesInvalidateResult(ICollection<QualifiedModuleName> mo`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- public class DeclarationInspectionResult<TProperties> : DeclarationInspectionResult`
	`47`	`+ public class DeclarationInspectionResult<T> : DeclarationInspectionResult, IWithInspectionResultProperties<T>`
`48`	`48`	`{`
`49`		`- private readonly TProperties _properties;`
`50`		`-`
`51`	`49`	`public DeclarationInspectionResult(`
`52`	`50`	`IInspection inspection,`
`53`	`51`	`string description,`
`54`	`52`	`Declaration target,`
`55`		`- TProperties properties,`
	`53`	`+ T properties,`
`56`	`54`	`QualifiedContext context = null,`
`57`	`55`	`ICollection<string> disabledQuickFixes = null) :`
`58`	`56`	`base(`
`@@ -62,17 +60,9 @@ public DeclarationInspectionResult(`
`62`	`60`	`context,`
`63`	`61`	`disabledQuickFixes)`
`64`	`62`	`{`
`65`		`- _properties = properties;`
	`63`	`+ Properties = properties;`
`66`	`64`	`}`
`67`	`65`
`68`		`- public override T Properties<T>()`
`69`		`- {`
`70`		`- if (_properties is T properties)`
`71`		`- {`
`72`		`- return properties;`
`73`		`- }`
`74`		`-`
`75`		`- return base.Properties<T>();`
`76`		`- }`
	`66`	`+ public T Properties { get; }`
`77`	`67`	`}`
`78`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,16 +44,14 @@ public override bool ChangesInvalidateResult(ICollection<QualifiedModuleName> mo`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- public class IdentifierReferenceInspectionResult<TProperties> : IdentifierReferenceInspectionResult`
	`47`	`+ public class IdentifierReferenceInspectionResult<T> : IdentifierReferenceInspectionResult, IWithInspectionResultProperties<T>`
`48`	`48`	`{`
`49`		`- private readonly TProperties _properties;`
`50`		`-`
`51`	`49`	`public IdentifierReferenceInspectionResult(`
`52`	`50`	`IInspection inspection,`
`53`	`51`	`string description,`
`54`	`52`	`IDeclarationFinderProvider declarationFinderProvider,`
`55`	`53`	`IdentifierReference reference,`
`56`		`- TProperties properties,`
	`54`	`+ T properties,`
`57`	`55`	`ICollection<string> disabledQuickFixes = null)`
`58`	`56`	`: base(`
`59`	`57`	`inspection,`
`@@ -62,17 +60,9 @@ public IdentifierReferenceInspectionResult(`
`62`	`60`	`reference,`
`63`	`61`	`disabledQuickFixes)`
`64`	`62`	`{`
`65`		`- _properties = properties;`
	`63`	`+ Properties = properties;`
`66`	`64`	`}`
`67`	`65`
`68`		`- public override T Properties<T>()`
`69`		`- {`
`70`		`- if (_properties is T properties)`
`71`		`- {`
`72`		`- return properties;`
`73`		`- }`
`74`		`-`
`75`		`- return base.Properties<T>();`
`76`		`- }`
	`66`	`+ public T Properties { get; }`
`77`	`67`	`}`
`78`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ public AccessSheetUsingCodeNameQuickFix(IDeclarationFinderProvider declarationFi`
`48`	`48`
`49`	`49`	`public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)`
`50`	`50`	`{`
`51`		`- var referenceResult = (IdentifierReferenceInspectionResult)result;`
	`51`	`+ var referenceResult = (IdentifierReferenceInspectionResult<string>)result;`
`52`	`52`
`53`	`53`	`var rewriter = rewriteSession.CheckOutModuleRewriter(referenceResult.QualifiedName);`
`54`	`54`
`@@ -62,7 +62,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio`
`62`	`62`	`var indexExprContext = referenceResult.Context.Parent.Parent as VBAParser.IndexExprContext ??`
`63`	`63`	`referenceResult.Context.Parent as VBAParser.IndexExprContext;`
`64`	`64`
`65`		`- var codeName = referenceResult.Properties<string>();`
	`65`	`+ var codeName = referenceResult.Properties;`
`66`	`66`	`rewriter.Replace(indexExprContext, codeName);`
`67`	`67`	`}`
`68`	`68`	`else`
`@@ -98,7 +98,7 @@ public override void Fix(IInspectionResult result, IRewriteSession rewriteSessio`
`98`	`98`
`99`	`99`	`foreach (var reference in sheetDeclaration.References)`
`100`	`100`	`{`
`101`		`- var codeName = referenceResult.Properties<string>();`
	`101`	`+ var codeName = referenceResult.Properties;`
`102`	`102`	`rewriter.Replace(reference.Context, codeName);`
`103`	`103`	`}`
`104`	`104`
Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,13 @@ public AddMissingAttributeQuickFix(IAttributesUpdater attributesUpdater)`
`54`	`54`
`55`	`55`	`public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)`
`56`	`56`	`{`
	`57`	`+ if (!(result is IWithInspectionResultProperties<IParseTreeAnnotation> resultProperties))`
	`58`	`+ {`
	`59`	`+ return;`
	`60`	`+ }`
	`61`	`+`
`57`	`62`	`var declaration = result.Target;`
`58`		`- var annotationInstance = result.Properties<IParseTreeAnnotation>();`
	`63`	`+ var annotationInstance = resultProperties.Properties;`
`59`	`64`	`if (!(annotationInstance.Annotation is IAttributeAnnotation annotation))`
`60`	`65`	`{`
`61`	`66`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -59,8 +59,13 @@ public AdjustAttributeAnnotationQuickFix(IAnnotationUpdater annotationUpdater, I`
`59`	`59`
`60`	`60`	`public override void Fix(IInspectionResult result, IRewriteSession rewriteSession)`
`61`	`61`	`{`
	`62`	`+ if (!(result is IWithInspectionResultProperties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)> resultProperties))`
	`63`	`+ {`
	`64`	`+ return;`
	`65`	`+ }`
	`66`	`+`
`62`	`67`	`var declaration = result.Target;`
`63`		`- var (oldParseTreeAnnotation, attributeBaseName, attributeValues) = result.Properties<(IParseTreeAnnotation Annotation, string AttributeName, IReadOnlyList<string> AttributeValues)>();`
	`68`	`+ var (oldParseTreeAnnotation, attributeBaseName, attributeValues) = resultProperties.Properties;`
`64`	`69`
`65`	`70`	`if (declaration.DeclarationType.HasFlag(DeclarationType.Module))`
`66`	`71`	`{`