Introduce inspections for indexed default member accesses

There are three versions: IndexedDefaultMemberAccessInspection for ordinary default member accesses, IndexedRecursiveDefaultMemberAccessInspection for those requiring a recursive default member resolution and IndexedUnboundDefaultMemberAccessInspection for those on Object and Variant variables.

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/IndexedDefaultMemberAccessInspection.cs

@@ -0,0 +1,74 @@
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Inspections;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies the use indexed default member accesses.
+    /// </summary>
+    /// <why>
+    /// An indexed default member access hides away the actually called member.
+    /// </why>
+    /// <example hasResult="true">
+    /// <![CDATA[
+    /// Class1:
+    ///
+    /// Public Function Foo(ByVal arg As Long) As Long
+    /// Attibute VB_UserMemId = 0
+    ///     Foo = 42
+    /// End Function
+    ///
+    /// Module:
+    /// 
+    /// Public Sub DoSomething(ByVal arg As Class1)
+    ///     Dim bar As Variant
+    ///     bar = arg(23)
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Class1:
+    ///
+    /// Public Function Foo(ByVal arg As Long) As Long
+    /// Attibute VB_UserMemId = 0
+    ///     Foo = 42
+    /// End Function
+    ///
+    /// Module:
+    /// 
+    /// Public Sub DoSomething(ByVal arg As Class1)
+    ///     Dim bar As Variant
+    ///     bar = arg.Foo(23)
+    /// End Sub
+    /// ]]>
+    /// </example>
+    public sealed class IndexedDefaultMemberAccessInspection : IdentifierReferenceInspectionBase
+    {
+        public IndexedDefaultMemberAccessInspection(RubberduckParserState state)
+            : base(state)
+        {
+            Severity = CodeInspectionSeverity.Hint;
+        }
+
+        protected override bool IsResultReference(IdentifierReference reference)
+        {
+            return reference.IsIndexedDefaultMemberAccess
+                   && reference.DefaultMemberRecursionDepth == 1
+                   && !(reference.Context is VBAParser.DictionaryAccessContext)
+                   && !reference.IsIgnoringInspectionResultFor(AnnotationName);
+        }
+
+        protected override string ResultDescription(IdentifierReference reference)
+        {
+            var expression = reference.IdentifierName;
+            var defaultMember = reference.Declaration.QualifiedName.ToString();
+            return string.Format(InspectionResults.IndexedDefaultMemberAccessInspection, expression, defaultMember);
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/IndexedRecursiveDefaultMemberAccessInspection.cs

@@ -0,0 +1,56 @@
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Inspections;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies the use indexed default member accesses that require a recursive default member resolution.
+    /// </summary>
+    /// <why>
+    /// An indexed default member access hides away the actually called member. This is especially problematic if the corresponding parameterized default member is not on the interface of the object itself.
+    /// </why>
+    /// <example hasResult="true">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As ADODB.Recordset)
+    ///     Dim bar As Variant
+    ///     bar = rst("MyField")
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As ADODB.Recordset)
+    ///     Dim bar As Variant
+    ///     bar = rst.Fields.Item("MyField")
+    /// End Sub
+    /// ]]>
+    /// </example>
+    public sealed class IndexedRecursiveDefaultMemberAccessInspection : IdentifierReferenceInspectionBase
+    {
+        public IndexedRecursiveDefaultMemberAccessInspection(RubberduckParserState state)
+            : base(state)
+        {
+            Severity = CodeInspectionSeverity.Suggestion;
+        }
+
+        protected override bool IsResultReference(IdentifierReference reference)
+        {
+            return reference.IsIndexedDefaultMemberAccess
+                   && reference.DefaultMemberRecursionDepth > 1
+                   && !(reference.Context is VBAParser.DictionaryAccessContext)
+                   && !reference.IsIgnoringInspectionResultFor(AnnotationName);
+        }
+
+        protected override string ResultDescription(IdentifierReference reference)
+        {
+            var expression = reference.IdentifierName;
+            var defaultMember = reference.Declaration.QualifiedName.ToString();
+            return string.Format(InspectionResults.IndexedRecursiveDefaultMemberAccessInspection, expression, defaultMember);
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/IndexedUnboundDefaultMemberAccessInspection.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing.Inspections;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies the use indexed default member accesses for which the default member cannot be determined at compile time.
+    /// </summary>
+    /// <why>
+    /// An indexed default member access hides away the actually called member. This is especially problematic if the default member cannot be determined from the declared type of the object.
+    /// Should there not be a suitable default member at runtime, an error 438 'Object doesn't support this property or method' will be raised.
+    /// </why>
+    /// <example hasResult="true">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As Object)
+    ///     Dim bar As Variant
+    ///     bar = rst("MyField")
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As Object)
+    ///     Dim bar As Variant
+    ///     bar = rst.Fields.Item("MyField")
+    /// End Sub
+    /// ]]>
+    /// </example>
+    public sealed class IndexedUnboundDefaultMemberAccessInspection : IdentifierReferenceInspectionBase
+    {
+        public IndexedUnboundDefaultMemberAccessInspection(RubberduckParserState state)
+            : base(state)
+        {
+            Severity = CodeInspectionSeverity.Warning;
+        }
+
+        protected override IEnumerable<IdentifierReference> ReferencesInModule(QualifiedModuleName module)
+        {
+            return DeclarationFinderProvider.DeclarationFinder.UnboundDefaultMemberAccesses(module);
+        }
+
+        protected override bool IsResultReference(IdentifierReference reference)
+        {
+            return reference.IsIndexedDefaultMemberAccess
+                   && !(reference.Context is VBAParser.DictionaryAccessContext)
+                   && !reference.IsIgnoringInspectionResultFor(AnnotationName);
+        }
+
+        protected override string ResultDescription(IdentifierReference reference)
+        {
+            var expression = reference.IdentifierName;
+            return string.Format(InspectionResults.IndexedUnboundDefaultMemberAccessInspection, expression);
+        }
+    }
+}

Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs

@@ -302,7 +302,7 @@ private void AddDefaultMemberReference(
             bool isSetAssignment)
         {
             var callSiteContext = expression.LExpression.Context;
-            var identifier = callSiteContext.GetText();
+            var identifier = expression.Context.GetText();
             var selection = callSiteContext.GetSelection();
             var callee = expression.ReferencedDeclaration;
             expression.ReferencedDeclaration.AddReference(
@@ -331,7 +331,7 @@ private void AddUnboundDefaultMemberReference(
             bool isSetAssignment)
         {
             var callSiteContext = expression.LExpression.Context;
-            var identifier = callSiteContext.GetText();
+            var identifier = expression.Context.GetText();
             var selection = callSiteContext.GetSelection();
             var callee = expression.ReferencedDeclaration;
             var reference = new IdentifierReference(

Rubberduck.Resources/Inspections/InspectionInfo.Designer.cs

@@ -412,4 +412,13 @@ Falls der Parameter 'null' sein kann, bitte dieses Auftreten ignorieren. 'null'
   <data name="ObjectWhereProcedureIsRequiredInspection" xml:space="preserve">
     <value>Wenn ein Objekt mit einem Standardmember an einer Stelle verwendet wird, die nach einer Prozedur verlangt, wird implizit der Standardmember aufgerufen. Die ist wahrscheinlich nicht beabsichtigt, minder aber zu Mindest die Lesbarkeit des Programms.</value>
   </data>
+  <data name="IndexedDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Zugriffe auf Standardmember verstecken, welcher Member aufgerufen wird. Auch wenn im Fall eines paramtrisierten Zugriffs ersichtlich ist, dass ein Zugriff erfolgt, so ist es in der Regel für die Lesbarkeit zuträglich explizit zu sein.</value>
+  </data>
+  <data name="IndexedRecursiveDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Zugriffe auf Standardmember verstecken, welcher Member aufgerufen wird. Auch wenn im Fall eines paramtrisierten Zugriffs ersichtlich ist, dass ein Zugriff erfolgt, so ist es in der Regel für die Lesbarkeit zuträglich explizit zu sein. Dies trifft besonders zu, wenn der Standardmember nicht auf dem Interface des Objekts selber zu finden ist uns stattdessen mittels einer Kette von Standrdmemberzugriffen erreicht werden muss.</value>
+  </data>
+  <data name="IndexedUnboundDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Zugriffe auf Standardmember verstecken, welcher Member aufgerufen wird. Auch wenn im Fall eines paramtrisierten Zugriffs ersichtlich ist, dass ein Zugriff erfolgt, so ist es in der Regel für die Lesbarkeit zuträglich explizit zu sein. Dies trifft insbesondere zu, wenn der Standardmember erst zur Laufzeit ermittelt werden kann. Sollte dann kein passender Standardmember existieren, kommt es zu einem Fehler 438 'Objekt unterstützt diese Eigenschaft oder Methode nicht'.</value>
+  </data>
 </root>

Rubberduck.Resources/Inspections/InspectionInfo.de.resx

@@ -415,4 +415,13 @@ If the parameter can be null, ignore this inspection result; passing a null valu
   <data name="ObjectWhereProcedureIsRequiredInspection" xml:space="preserve">
     <value>Using an object with a default member in a place that requires a procedure leads to an implicit invocation of the default member. This is most likely unintentional and negatively affects readability.</value>
   </data>
+  <data name="IndexedDefaultMemberAccessInspection" xml:space="preserve">
+    <value>A default member access hides away which member is actually called. Although it is apparent that some call is made in the case of an indexed default member access being explicit is usually better for readability.</value>
+  </data>
+  <data name="IndexedRecursiveDefaultMemberAccessInspection" xml:space="preserve">
+    <value>A default member access hides away which member is actually called. Although it is apparent that some call is made in the case of an indexed default member access being explicit is usually better for readability. This especially holds if the accessed default member is not on the interface of the object itself but has to be resolved via a chain of default member calls.</value>
+  </data>
+  <data name="IndexedUnboundDefaultMemberAccessInspection" xml:space="preserve">
+    <value>A default member access hides away which member is actually called. Although it is apparent that some call is made in the case of an indexed default member access being explicit is usually better for readability. This is especially true if the default member cannot be determined at compile time. In addition, should there not be a suitable default member at runtime, an error 438 'Object doesn't support this property or method' will be raised.</value>
+  </data>
 </root>

Rubberduck.Resources/Inspections/InspectionInfo.resx

@@ -399,4 +399,13 @@
   <data name="ObjectWhereProcedureIsRequiredInspection" xml:space="preserve">
     <value>Objekt an Stell einer Prozedur verwendet</value>
   </data>
+  <data name="IndexedDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Parametrisierter Zugriff auf einen Standardmember</value>
+  </data>
+  <data name="IndexedRecursiveDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Parametrisierter rekursiver Zugriff auf einen Standardmember</value>
+  </data>
+  <data name="IndexedUnboundDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Parametrisierter nicht gebundener Zugriff auf einen Standardmember</value>
+  </data>
 </root>

Rubberduck.Resources/Inspections/InspectionNames.Designer.cs

@@ -419,4 +419,13 @@
   <data name="ObjectWhereProcedureIsRequiredInspection" xml:space="preserve">
     <value>Object used where a procedure is required</value>
   </data>
+  <data name="IndexedDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Use of an indexed default member access</value>
+  </data>
+  <data name="IndexedRecursiveDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Use of an indexed recursive default member access</value>
+  </data>
+  <data name="IndexedUnboundDefaultMemberAccessInspection" xml:space="preserve">
+    <value>Use of an indexed unbound default member access</value>
+  </data>
 </root>