Merge pull request #5166 from MDoerner/DefaultMemberAccessInspections

Default member access inspections

Author: bclothier

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitDefaultMemberAccessInspection.cs

@@ -0,0 +1,72 @@
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Parsing.Inspections;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies the use of non-indexed default member accesses.
+    /// </summary>
+    /// <why>
+    /// Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made
+    /// and can cause errors in which a member was forgotten to be called to go unnoticed.
+    /// </why>
+    /// <example hasResult="true">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As ADODB.Field)
+    ///     Dim bar As Variant
+    ///     bar = arg
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="true">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As ADODB.Connection)
+    ///     Dim bar As String
+    ///     arg = bar
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As ADODB.Field)
+    ///     Dim bar As Variant
+    ///     bar = arg.Value
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As ADODB.Connection)
+    ///     Dim bar As String
+    ///     arg.ConnectionString = bar
+    /// End Sub
+    /// ]]>
+    public sealed class ImplicitDefaultMemberAccessInspection : IdentifierReferenceInspectionBase
+    {
+        public ImplicitDefaultMemberAccessInspection(RubberduckParserState state)
+            : base(state)
+        {
+            Severity = CodeInspectionSeverity.Suggestion;
+        }
+
+        protected override bool IsResultReference(IdentifierReference reference)
+        {
+            return reference.IsNonIndexedDefaultMemberAccess
+                   && reference.DefaultMemberRecursionDepth == 1
+                   && !reference.IsProcedureCoercion
+                   && !reference.IsInnerRecursiveDefaultMemberAccess
+                   && !reference.IsIgnoringInspectionResultFor(AnnotationName);
+        }
+
+        protected override string ResultDescription(IdentifierReference reference)
+        {
+            var expression = reference.IdentifierName;
+            var defaultMember = reference.Declaration.QualifiedName.ToString();
+            return string.Format(InspectionResults.ImplicitDefaultMemberAccessInspection, expression, defaultMember);
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitDefaultMemberAssignmentInspection.cs

@@ -0,0 +1,93 @@
+using Rubberduck.Inspections.Abstract;
+using Rubberduck.Resources.Inspections;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.Inspections.Inspections.Extensions;
+using Rubberduck.Parsing.Inspections;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies the use of indexed default member accesses that require a recursive default member resolution.
+    /// </summary>
+    /// <why>
+    /// Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made
+    /// and the final default member is not on the interface of the object itself. In particular, this can cause errors in which a member was forgotten to be called to go unnoticed.
+    /// </why>
+    /// <example hasResult="true">
+    /// <module name="Class1" type="Class Module">
+    /// <![CDATA[
+    /// Public Function Foo() As Class2
+    /// Attibute Foo.VB_UserMemId = 0
+    ///     Set Foo = New Class2
+    /// End Function
+    /// ]]>
+    /// </module>
+    /// <module name="Class2" type="Class Module">
+    /// <![CDATA[
+    /// Public Function Bar() As Long
+    /// Attibute Bar.VB_UserMemId = 0
+    ///     Foo = 42
+    /// End Function
+    /// ]]>
+    /// </module>
+    /// <module name="Module" type="Standard Module">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As Class1)
+    ///     Dim bar As Variant
+    ///     bar = arg
+    /// End Sub
+    /// ]]>
+    /// </module>
+    /// </example>
+    /// <example hasResult="false">
+    /// <module name="Class1" type="Class Module">
+    /// <![CDATA[
+    /// Public Function Foo() As Class2
+    /// Attibute Foo.VB_UserMemId = 0
+    ///     Set Foo = New Class2
+    /// End Function
+    /// ]]>
+    /// </module>
+    /// <module name="Class2" type="Class Module">
+    /// <![CDATA[
+    /// Public Function Bar() As Long
+    /// Attibute Bar.VB_UserMemId = 0
+    ///     Foo = 42
+    /// End Function
+    /// ]]>
+    /// </module>
+    /// <module name="Module" type="Standard Module">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As Class1)
+    ///     Dim bar As Variant
+    ///     bar = arg.Foo().Bar()
+    /// End Sub
+    /// ]]>
+    /// </module>
+    /// </example>
+    public sealed class ImplicitRecursiveDefaultMemberAccessInspection : IdentifierReferenceInspectionBase
+    {
+        public ImplicitRecursiveDefaultMemberAccessInspection(RubberduckParserState state)
+            : base(state)
+        {
+            Severity = CodeInspectionSeverity.Suggestion;
+        }
+
+        protected override bool IsResultReference(IdentifierReference reference)
+        {
+            return reference.IsNonIndexedDefaultMemberAccess
+                   && reference.DefaultMemberRecursionDepth > 1
+                   && !reference.IsProcedureCoercion
+                   && !reference.IsInnerRecursiveDefaultMemberAccess
+                   && !reference.IsIgnoringInspectionResultFor(AnnotationName);
+        }
+
+        protected override string ResultDescription(IdentifierReference reference)
+        {
+            var expression = reference.IdentifierName;
+            var defaultMember = reference.Declaration.QualifiedName.ToString();
+            return string.Format(InspectionResults.ImplicitRecursiveDefaultMemberAccessInspection, expression, defaultMember);
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitRecursiveDefaultMemberAccessInspection.cs

@@ -0,0 +1,77 @@
+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.Inspections;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Inspections.Concrete
+{
+    /// <summary>
+    /// Identifies the use of indexed default member accesses for which the default member cannot be determined at compile time.
+    /// </summary>
+    /// <why>
+    /// Default member accesses hide away the actually called member. This is especially misleading if there is no indication in the expression that such a call is made
+    /// and if the default member cannot be determined from the declared type of the object. As a consequence, errors in which a member was forgotten to be called can go unnoticed
+    /// and 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 = arg
+    /// End Sub
+    /// ]]>
+    /// <example hasResult="true">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As Object)
+    ///     Dim bar As Variant
+    ///     arg = bar
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As Object)
+    ///     Dim bar As Variant
+    ///     bar = arg.SomeValueReturningMember
+    /// End Sub
+    /// ]]>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal arg As Object)
+    ///     Dim bar As Variant
+    ///     arg.SomePropertyLet = bar
+    /// End Sub
+    /// ]]>
+    /// </example>
+    public sealed class ImplicitUnboundDefaultMemberAccessInspection : IdentifierReferenceInspectionBase
+    {
+        public ImplicitUnboundDefaultMemberAccessInspection(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.IsNonIndexedDefaultMemberAccess
+                   && !reference.IsProcedureCoercion
+                   && !reference.IsInnerRecursiveDefaultMemberAccess
+                   && !reference.IsIgnoringInspectionResultFor(AnnotationName);
+        }
+
+        protected override string ResultDescription(IdentifierReference reference)
+        {
+            var expression = reference.IdentifierName;
+            return string.Format(InspectionResults.ImplicitUnboundDefaultMemberAccessInspection, expression);
+        }
+    }
+}

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitUnboundDefaultMemberAccessInspection.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 of indexed default member accesses.
+    /// </summary>
+    /// <why>
+    /// An indexed default member access hides away the actually called member.
+    /// </why>
+    /// <example hasResult="true">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal coll As Collection)
+    ///     Dim bar As Variant
+    ///     bar = coll(23)
+    /// End Sub
+    /// ]]>
+    /// </example>
+    /// <example hasResult="false">
+    /// <![CDATA[
+    /// Public Sub DoSomething(ByVal coll As Collection)
+    ///     Dim bar As Variant
+    ///     bar = coll.Item(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);
+        }
+    }
+}