Merge pull request #4207 from comintern/next

Test for anonymous object access in With blocks. Fixes #3343

Author: retailcoder

Rubberduck.CodeAnalysis/Inspections/Concrete/MemberNotOnInterfaceInspection.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Inspections.Abstract;
 using Rubberduck.Resources.Inspections;
 using Rubberduck.Parsing.Symbols;
@@ -23,12 +24,19 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
                                                      decl.AsTypeDeclaration.DeclarationType.HasFlag(DeclarationType.ClassModule) &&
                                                      ((ClassModuleDeclaration)decl.AsTypeDeclaration).IsExtensible)
                                        .SelectMany(decl => decl.References).ToList();
-            return from access in unresolved
-                   let callingContext = targets.FirstOrDefault(usage => usage.Context.Equals(access.CallingContext))
-                   where callingContext != null
-                   select new DeclarationInspectionResult(this,
-                        string.Format(InspectionResults.MemberNotOnInterfaceInspection, access.IdentifierName, callingContext.Declaration.AsTypeDeclaration.IdentifierName),
-                        access);
+            return unresolved
+                .Select(access => new
+                {
+                    access,
+                    callingContext = targets.FirstOrDefault(usage => usage.Context.Equals(access.CallingContext)
+                                                                     || (access.CallingContext is VBAParser.NewExprContext && 
+                                                                         usage.Context.Parent.Parent.Equals(access.CallingContext))
+                                                                     )
+                })
+                .Where(memberAccess => memberAccess.callingContext != null)
+                .Select(memberAccess => new DeclarationInspectionResult(this,
+                    string.Format(InspectionResults.MemberNotOnInterfaceInspection, memberAccess.access.IdentifierName,
+                        memberAccess.callingContext.Declaration.AsTypeDeclaration.IdentifierName), memberAccess.access));
         }
     }
 }

Rubberduck.CodeAnalysis/Inspections/Concrete/ParameterCanBeByValInspection.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using Rubberduck.Common;
 using Rubberduck.Inspections.Abstract;
@@ -91,6 +92,9 @@ private IEnumerable<IInspectionResult> GetResults(Declaration[] declarations, De
 
                     for (var i = 0; i < parameters.Count; i++)
                     {
+                        //If you hit this assert, congratulations! you've found a test case for https://github.com/rubberduck-vba/Rubberduck/issues/3906
+                        //Please examine the code, and if possible, either fix the indexing on this or upload your failing code to the GitHub issue.
+                        Debug.Assert(parametersAreByRef.Count == parameters.Count);
                         parametersAreByRef[i] = parametersAreByRef[i] &&
                                                 !IsUsedAsByRefParam(declarations, parameters[i]) &&
                                                 ((VBAParser.ArgContext) parameters[i].Context).BYVAL() == null &&

RubberduckTests/Inspections/MemberNotOnInterfaceInspectionTests.cs

@@ -255,6 +255,66 @@ Dim dict As Dictionary
             }
         }
 
+        [Test]
+        [Category("Inspections")]
+        public void MemberNotOnInterface_WithNewReturnsResult()
+        {
+            const string inputCode =
+                @"Sub Foo()
+    With New Dictionary
+        Debug.Print .FooBar
+    End With
+End Sub";
+
+            using (var state = ArrangeParserAndParse(inputCode))
+            {
+                var inspection = new MemberNotOnInterfaceInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.AreEqual(1, inspectionResults.Count());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void MemberNotOnInterface_DoesNotReturnResult_WithNewBlockBangNotation()
+        {
+            const string inputCode =
+                @"Sub Foo()
+    With New Dictionary
+        !FooBar = 42
+    End With
+End Sub";
+
+            using (var state = ArrangeParserAndParse(inputCode))
+            {
+                var inspection = new MemberNotOnInterfaceInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.IsFalse(inspectionResults.Any());
+            }
+        }
+
+        [Test]
+        [Category("Inspections")]
+        public void MemberNotOnInterface_DoesNotReturnResult_WithNewBlockOnInterface()
+        {
+            const string inputCode =
+                @"Sub Foo()
+    With New Dictionary
+        .Add 42, 42
+    End With
+End Sub";
+
+            using (var state = ArrangeParserAndParse(inputCode))
+            {
+                var inspection = new MemberNotOnInterfaceInspection(state);
+                var inspectionResults = inspection.GetInspectionResults(CancellationToken.None);
+
+                Assert.IsFalse(inspectionResults.Any());
+            }
+        }
+
         [Test]
         [Category("Inspections")]
         public void MemberNotOnInterface_CatchesInvalidUseOfMember()