Introduced dynamic object for custom properties of inspection results

rkapka · rkapka · commit 0df81070fb45 · 2018-01-01T01:16:36.000+01:00
diff --git a/RetailCoder.VBE/UI/Inspections/AggregateInspectionResult.cs b/RetailCoder.VBE/UI/Inspections/AggregateInspectionResult.cs
@@ -1,5 +1,4 @@
 ﻿using System;
-using System.Collections.Generic;
 using Antlr4.Runtime;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Inspections.Resources;
@@ -29,16 +28,16 @@ public AggregateInspectionResult(IInspectionResult firstResult, int count)
 
         public ParserRuleContext Context => _result.Context;
 
-        public IDictionary<string, string> Properties => throw new NotImplementedException();
+        public dynamic Properties => throw new NotImplementedException();
 
         public int CompareTo(IInspectionResult other)
         {
             if (other == this)
             {
                 return 0;
             }
-            var aggregated = other as AggregateInspectionResult;
-            if (aggregated == null)
+
+            if (!(other is AggregateInspectionResult aggregated))
             {
                 return -1;
             }
diff --git a/Rubberduck.Inspections/Abstract/InspectionResultBase.cs b/Rubberduck.Inspections/Abstract/InspectionResultBase.cs
@@ -1,7 +1,7 @@
-﻿using System.Collections.Generic;
-using System.IO;
+﻿using System.IO;
 using Antlr4.Runtime;
 using Rubberduck.Common;
+using Rubberduck.Parsing.Inspections;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Inspections.Resources;
 using Rubberduck.Parsing.Symbols;
@@ -20,7 +20,7 @@ protected InspectionResultBase(IInspection inspection,
             Declaration target,
             QualifiedSelection qualifiedSelection,
             QualifiedMemberName? qualifiedMemberName,
-            Dictionary<string, string> properties)
+            dynamic properties)
         {
             Inspection = inspection;
             Description = description?.Capitalize();
@@ -29,7 +29,7 @@ protected InspectionResultBase(IInspection inspection,
             Target = target;
             QualifiedSelection = qualifiedSelection;
             QualifiedMemberName = qualifiedMemberName;
-            Properties = properties ?? new Dictionary<string, string>();
+            Properties = properties ?? new PropertyBag();
         }
 
         public IInspection Inspection { get; }
@@ -38,7 +38,7 @@ protected InspectionResultBase(IInspection inspection,
         public QualifiedMemberName? QualifiedMemberName { get; }
         public ParserRuleContext Context { get; }
         public Declaration Target { get; }
-        public IDictionary<string, string> Properties { get; }
+        public dynamic Properties { get; }
 
         /// <summary>
         /// Gets the information needed to select the target instruction in the VBE.
diff --git a/Rubberduck.Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs b/Rubberduck.Inspections/Concrete/FunctionReturnValueNotUsedInspection.cs
@@ -5,6 +5,7 @@
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
 using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Inspections;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Inspections.Resources;
 using Rubberduck.Parsing.Symbols;
@@ -40,21 +41,19 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
         private IEnumerable<IInspectionResult> GetInterfaceMemberIssues(IEnumerable<Declaration> interfaceMembers)
         {
             return from interfaceMember in interfaceMembers
-                   let implementationMembers =
-                       UserDeclarations.FindInterfaceImplementationMembers(interfaceMember.IdentifierName).ToList()
-                   where interfaceMember.DeclarationType == DeclarationType.Function &&
-                       !IsReturnValueUsed(interfaceMember) &&
-                       implementationMembers.All(member => !IsReturnValueUsed(member))
-                   let implementationMemberIssues =
-                       implementationMembers.Select(
-                           implementationMember =>
-                               Tuple.Create(implementationMember.Context,
-                                   new QualifiedSelection(implementationMember.QualifiedName.QualifiedModuleName,
-                                       implementationMember.Selection), implementationMember))
-                   select
-                       new DeclarationInspectionResult(this,
-                                            string.Format(InspectionsUI.FunctionReturnValueNotUsedInspectionResultFormat, interfaceMember.IdentifierName),
-                                            interfaceMember, properties: new Dictionary<string, string> { { "DisableFixes", nameof(QuickFixes.ConvertToProcedureQuickFix) } });
+                let implementationMembers =
+                    UserDeclarations.FindInterfaceImplementationMembers(interfaceMember.IdentifierName).ToList()
+                where interfaceMember.DeclarationType == DeclarationType.Function &&
+                      !IsReturnValueUsed(interfaceMember) &&
+                      implementationMembers.All(member => !IsReturnValueUsed(member))
+                let implementationMemberIssues =
+                    implementationMembers.Select(
+                        implementationMember =>
+                            Tuple.Create(implementationMember.Context,
+                                new QualifiedSelection(implementationMember.QualifiedName.QualifiedModuleName,
+                                    implementationMember.Selection), implementationMember))
+                select CreateInspectionResult(this, interfaceMember);
+
         }
 
         private IEnumerable<IInspectionResult> GetNonInterfaceIssues(IEnumerable<Declaration> nonInterfaceFunctions)
@@ -149,5 +148,16 @@ private bool IsSet(IdentifierReference usage)
 
             return setStmt != null && setStmt == usage.Context;
         }
+
+        private DeclarationInspectionResult CreateInspectionResult(IInspection inspection, Declaration interfaceMember)
+        {
+            dynamic properties = new PropertyBag();
+            properties.DisableFixes = nameof(QuickFixes.ConvertToProcedureQuickFix);
+
+            return new DeclarationInspectionResult(inspection,
+                string.Format(InspectionsUI.FunctionReturnValueNotUsedInspectionResultFormat,
+                    interfaceMember.IdentifierName),
+                interfaceMember, properties: properties);
+        }
     }
 }
diff --git a/Rubberduck.Inspections/Concrete/UseMeaningfulNameInspection.cs b/Rubberduck.Inspections/Concrete/UseMeaningfulNameInspection.cs
@@ -4,6 +4,7 @@
 using Rubberduck.Common;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Inspections;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Inspections.Resources;
 using Rubberduck.Parsing.Symbols;
@@ -51,15 +52,26 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                                 !whitelistedNames.Contains(declaration.IdentifierName) &&
                                 !VariableNameValidator.IsMeaningfulName(declaration.IdentifierName));
 
-            return (from issue in issues
-                    let props = issue.DeclarationType.HasFlag(DeclarationType.Module) ||
-                                issue.DeclarationType.HasFlag(DeclarationType.Project)
-                        ? new Dictionary<string, string> {{"DisableFixes", "IgnoreOnceQuickFix"}} : null
-                    select new DeclarationInspectionResult(this,
-                        string.Format(InspectionsUI.IdentifierNameInspectionResultFormat,
-                            RubberduckUI.ResourceManager.GetString("DeclarationType_" + issue.DeclarationType,
-                                CultureInfo.CurrentUICulture), issue.IdentifierName), issue, properties: props))
+            return (from issue in issues select CreateInspectionResult(this, issue))
                 .ToList();
         }
+
+        private static DeclarationInspectionResult CreateInspectionResult(IInspection inspection, Declaration issue)
+        {
+            dynamic properties = null;
+
+            if (issue.DeclarationType.HasFlag(DeclarationType.Module) ||
+                issue.DeclarationType.HasFlag(DeclarationType.Project))
+            {
+                properties = new PropertyBag();
+                properties.DisableFixes = "IgnoreOnceQuickFix";
+            }
+
+            return new DeclarationInspectionResult(inspection,
+                string.Format(InspectionsUI.IdentifierNameInspectionResultFormat,
+                    RubberduckUI.ResourceManager.GetString("DeclarationType_" + issue.DeclarationType,
+                        CultureInfo.CurrentUICulture), issue.IdentifierName),
+                issue, properties: properties);
+        }
     }
 }
diff --git a/Rubberduck.Inspections/QuickFixProvider.cs b/Rubberduck.Inspections/QuickFixProvider.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using Microsoft.CSharp.RuntimeBinder;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
@@ -40,15 +41,25 @@ public IEnumerable<IQuickFix> QuickFixes(IInspectionResult result)
             }
 
             return _quickFixes[result.Inspection.GetType()].Where(fix =>
-            {
-                if (!result.Properties.TryGetValue("DisableFixes", out var value))
                 {
-                    return true;
-                }
+                    string value;
+                    try
+                    {
+                        value = result.Properties.DisableFixes;
+                    }
+                    catch (RuntimeBinderException)
+                    {
+                        return true;
+                    }
+
+                    if (value == null)
+                    {
+                        return true;
+                    }
 
-                return !value.Split(',').Contains(fix.GetType().Name);
-            })
-            .OrderBy(fix => fix.SupportedInspections.Count); // most specific fixes first; keeps "ignore once" last
+                    return !value.Split(',').Contains(fix.GetType().Name);
+                })
+                .OrderBy(fix => fix.SupportedInspections.Count); // most specific fixes first; keeps "ignore once" last
         }
 
         private bool CanFix(IQuickFix fix, IInspectionResult result)
diff --git a/Rubberduck.Inspections/Results/DeclarationInspectionResult.cs b/Rubberduck.Inspections/Results/DeclarationInspectionResult.cs
@@ -1,5 +1,4 @@
-﻿using System.Collections.Generic;
-using Rubberduck.Inspections.Abstract;
+﻿using Rubberduck.Inspections.Abstract;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Parsing.Symbols;
@@ -9,15 +8,15 @@ namespace Rubberduck.Inspections.Results
 {
     internal class DeclarationInspectionResult : InspectionResultBase
     {
-        public DeclarationInspectionResult(IInspection inspection, string description, Declaration target, QualifiedContext context = null, Dictionary<string, string> properties = null) :
+        public DeclarationInspectionResult(IInspection inspection, string description, Declaration target, QualifiedContext context = null, dynamic properties = null) :
             base(inspection,
                  description,
                  context == null ? target.QualifiedName.QualifiedModuleName : context.ModuleName,
                  context == null ? target.Context : context.Context,
                  target,
                  target.QualifiedSelection,
                  GetQualifiedMemberName(target),
-                 properties)
+                 (object)properties)
         {
         }
         
diff --git a/Rubberduck.Inspections/Results/IdentifierReferenceInspectionResult.cs b/Rubberduck.Inspections/Results/IdentifierReferenceInspectionResult.cs
@@ -1,5 +1,4 @@
-﻿using System.Collections.Generic;
-using System.Linq;
+﻿using System.Linq;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Inspections.Abstract;
@@ -11,15 +10,15 @@ namespace Rubberduck.Inspections.Results
 {
     internal class IdentifierReferenceInspectionResult : InspectionResultBase
     {
-        public IdentifierReferenceInspectionResult(IInspection inspection, string description, RubberduckParserState state, IdentifierReference reference, Dictionary<string, string> properties = null) :
+        public IdentifierReferenceInspectionResult(IInspection inspection, string description, RubberduckParserState state, IdentifierReference reference, dynamic properties = null) :
             base(inspection,
                  description,
                  reference.QualifiedModuleName,
                  reference.Context,
                  reference.Declaration,
                  new QualifiedSelection(reference.QualifiedModuleName, reference.Context.GetSelection()),
                  GetQualifiedMemberName(state, reference),
-                 properties)
+                 (object)properties)
         {
         }
 
diff --git a/Rubberduck.Inspections/Results/QualifiedContextInspectionResult.cs b/Rubberduck.Inspections/Results/QualifiedContextInspectionResult.cs
@@ -1,5 +1,4 @@
-﻿using System.Collections.Generic;
-using Rubberduck.Inspections.Abstract;
+﻿using Rubberduck.Inspections.Abstract;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.VBEditor;
@@ -8,15 +7,15 @@ namespace Rubberduck.Inspections.Results
 {
     internal class QualifiedContextInspectionResult : InspectionResultBase
     {
-        public QualifiedContextInspectionResult(IInspection inspection, string description, QualifiedContext context, Dictionary<string, string> properties = null) :
+        public QualifiedContextInspectionResult(IInspection inspection, string description, QualifiedContext context, dynamic properties = null) :
             base(inspection,
                  description,
                  context.ModuleName,
                  context.Context,
                  null,
                  new QualifiedSelection(context.ModuleName, context.Context.GetSelection()),
                  context.MemberName,
-                 properties)
+                 (object)properties)
         {
         }
     }
diff --git a/Rubberduck.Parsing/Inspections/Abstract/IInspectionResult.cs b/Rubberduck.Parsing/Inspections/Abstract/IInspectionResult.cs
@@ -1,5 +1,4 @@
 ﻿using System;
-using System.Collections.Generic;
 using Antlr4.Runtime;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.VBEditor;
@@ -14,6 +13,6 @@ public interface IInspectionResult : IComparable<IInspectionResult>, IComparable
         IInspection Inspection { get; }
         Declaration Target { get; }
         ParserRuleContext Context { get; }
-        IDictionary<string, string> Properties { get; }
+        dynamic Properties { get; }
     }
 }
diff --git a/Rubberduck.Parsing/Inspections/PropertyBag.cs b/Rubberduck.Parsing/Inspections/PropertyBag.cs
@@ -0,0 +1,26 @@
+﻿using System.Collections.Generic;
+using System.Dynamic;
+
+namespace Rubberduck.Parsing.Inspections
+{
+    public class PropertyBag : DynamicObject
+    {
+        readonly Dictionary<string, object> _properties = new Dictionary<string, object>();
+
+        public override bool TryGetMember(GetMemberBinder binder, out object result)
+        {
+            return _properties.TryGetValue(binder.Name, out result);
+        }
+
+        public override bool TrySetMember(SetMemberBinder binder, object value)
+        {
+            _properties[binder.Name] = value;
+            return true;
+        }
+
+        public override IEnumerable<string> GetDynamicMemberNames()
+        {
+            return _properties.Keys;
+        }
+    }
+}
diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -153,6 +153,7 @@
     <Compile Include="Inspections\Abstract\IInspector.cs" />
     <Compile Include="Inspections\Abstract\IParseTreeInspection.cs" />
     <Compile Include="Inspections\Abstract\IQuickFix.cs" />
+    <Compile Include="Inspections\PropertyBag.cs" />
     <Compile Include="Symbols\ParsingExceptions\MainParseExceptionErrorListener.cs" />
     <Compile Include="Symbols\ParsingExceptions\PreprocessorExceptionErrorListener.cs" />
     <Compile Include="Symbols\ParsingExceptions\ParsePassExceptionErrorListener.cs" />
diff --git a/RubberduckTests/QuickFixes/QuickFixProviderTests.cs b/RubberduckTests/QuickFixes/QuickFixProviderTests.cs
@@ -76,7 +76,7 @@ public void ResultDisablesFix()
                 var quickFixProvider = new QuickFixProvider(state, new IQuickFix[] { new RemoveUnusedDeclarationQuickFix(state) });
 
                 var result = inspectionResults.First();
-                result.Properties.Add("DisableFixes", nameof(RemoveUnusedDeclarationQuickFix));
+                result.Properties.DisableFixes = nameof(RemoveUnusedDeclarationQuickFix);
 
                 Assert.AreEqual(0, quickFixProvider.QuickFixes(result).Count());
             }

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
`3`	`2`	`using Antlr4.Runtime;`
`4`	`3`	`using Rubberduck.Parsing.Inspections.Abstract;`
`5`	`4`	`using Rubberduck.Parsing.Inspections.Resources;`
`@@ -29,16 +28,16 @@ public AggregateInspectionResult(IInspectionResult firstResult, int count)`
`29`	`28`
`30`	`29`	`public ParserRuleContext Context => _result.Context;`
`31`	`30`
`32`		`- public IDictionary<string, string> Properties => throw new NotImplementedException();`
	`31`	`+ public dynamic Properties => throw new NotImplementedException();`
`33`	`32`
`34`	`33`	`public int CompareTo(IInspectionResult other)`
`35`	`34`	`{`
`36`	`35`	`if (other == this)`
`37`	`36`	`{`
`38`	`37`	`return 0;`
`39`	`38`	`}`
`40`		`- var aggregated = other as AggregateInspectionResult;`
`41`		`- if (aggregated == null)`
	`39`	`+`
	`40`	`+ if (!(other is AggregateInspectionResult aggregated))`
`42`	`41`	`{`
`43`	`42`	`return -1;`
`44`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`		`-using System.Collections.Generic;`
`2`		`-using Rubberduck.Inspections.Abstract;`
	`1`	`+using Rubberduck.Inspections.Abstract;`
`3`	`2`	`using Rubberduck.Parsing;`
`4`	`3`	`using Rubberduck.Parsing.Inspections.Abstract;`
`5`	`4`	`using Rubberduck.Parsing.Symbols;`
`@@ -9,15 +8,15 @@ namespace Rubberduck.Inspections.Results`
`9`	`8`	`{`
`10`	`9`	`internal class DeclarationInspectionResult : InspectionResultBase`
`11`	`10`	`{`
`12`		`- public DeclarationInspectionResult(IInspection inspection, string description, Declaration target, QualifiedContext context = null, Dictionary<string, string> properties = null) :`
	`11`	`+ public DeclarationInspectionResult(IInspection inspection, string description, Declaration target, QualifiedContext context = null, dynamic properties = null) :`
`13`	`12`	`base(inspection,`
`14`	`13`	`description,`
`15`	`14`	`context == null ? target.QualifiedName.QualifiedModuleName : context.ModuleName,`
`16`	`15`	`context == null ? target.Context : context.Context,`
`17`	`16`	`target,`
`18`	`17`	`target.QualifiedSelection,`
`19`	`18`	`GetQualifiedMemberName(target),`
`20`		`- properties)`
	`19`	`+ (object)properties)`
`21`	`20`	`{`
`22`	`21`	`}`
`23`	`22`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`		`-using System.Collections.Generic;`
`2`		`-using System.Linq;`
	`1`	`+using System.Linq;`
`3`	`2`	`using Rubberduck.Inspections.Abstract;`
`4`	`3`	`using Rubberduck.Parsing;`
`5`	`4`	`using Rubberduck.Parsing.Inspections.Abstract;`
`@@ -11,15 +10,15 @@ namespace Rubberduck.Inspections.Results`
`11`	`10`	`{`
`12`	`11`	`internal class IdentifierReferenceInspectionResult : InspectionResultBase`
`13`	`12`	`{`
`14`		`- public IdentifierReferenceInspectionResult(IInspection inspection, string description, RubberduckParserState state, IdentifierReference reference, Dictionary<string, string> properties = null) :`
	`13`	`+ public IdentifierReferenceInspectionResult(IInspection inspection, string description, RubberduckParserState state, IdentifierReference reference, dynamic properties = null) :`
`15`	`14`	`base(inspection,`
`16`	`15`	`description,`
`17`	`16`	`reference.QualifiedModuleName,`
`18`	`17`	`reference.Context,`
`19`	`18`	`reference.Declaration,`
`20`	`19`	`new QualifiedSelection(reference.QualifiedModuleName, reference.Context.GetSelection()),`
`21`	`20`	`GetQualifiedMemberName(state, reference),`
`22`		`- properties)`
	`21`	`+ (object)properties)`
`23`	`22`	`{`
`24`	`23`	`}`
`25`	`24`