Merge pull request #5224 from MDoerner/FixAttributesRecovery

retailcoder · web-flow · commit 3d5370acb468 · 2019-10-18T00:15:03.000-04:00
Fix member attributes recovery for properties
diff --git a/Rubberduck.Core/UI/Notifiers/MemberAttributeRecoveryFailureNotifier.cs b/Rubberduck.Core/UI/Notifiers/MemberAttributeRecoveryFailureNotifier.cs
@@ -1,7 +1,9 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Linq;
 using Rubberduck.Interaction;
 using Rubberduck.Parsing.Rewriter;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.UI.Notifiers
@@ -44,18 +46,19 @@ private static string RewriteFailureReasonMessage(RewriteSessionState sessionSta
             }
         }
 
-        public void NotifyMembersForRecoveryNotFound(IEnumerable<QualifiedMemberName> membersNotFound)
+        public void NotifyMembersForRecoveryNotFound(IEnumerable<(QualifiedMemberName memberName, DeclarationType memberType)> membersNotFound)
         {
             var message = MembersNotFoundMessage(membersNotFound);
             var caption = Resources.RubberduckUI.MemberAttributeRecoveryFailureCaption;
 
             _messageBox.NotifyWarn(message, caption);
         }
 
-        private string MembersNotFoundMessage(IEnumerable<QualifiedMemberName> membersNotFound)
+        private string MembersNotFoundMessage(IEnumerable<(QualifiedMemberName memberName, DeclarationType memberType)> membersNotFound)
         {
-            var missingMemberList = $"{Environment.NewLine}{string.Join(Environment.NewLine, membersNotFound)}";
-            return string.Format(Resources.RubberduckUI.MemberAttributeRecoveryMembersNotFoundMessage, missingMemberList); ;
+            var missingMemberTexts = membersNotFound.Select(tpl => $"{tpl.memberName} ({tpl.memberType})");
+            var missingMemberList = $"{Environment.NewLine}{string.Join(Environment.NewLine, missingMemberTexts)}";
+            return string.Format(Resources.RubberduckUI.MemberAttributeRecoveryMembersNotFoundMessage, missingMemberList);
         }
     }
 }
diff --git a/Rubberduck.Parsing/Rewriter/IMemberAttributeRecoveryFailureNotifier.cs b/Rubberduck.Parsing/Rewriter/IMemberAttributeRecoveryFailureNotifier.cs
@@ -1,11 +1,12 @@
 ﻿using System.Collections.Generic;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.VBEditor;
 
 namespace Rubberduck.Parsing.Rewriter
 {
     public interface IMemberAttributeRecoveryFailureNotifier
     {
         void NotifyRewriteFailed(RewriteSessionState rewriteSessionState);
-        void NotifyMembersForRecoveryNotFound(IEnumerable<QualifiedMemberName> membersNotFound);
+        void NotifyMembersForRecoveryNotFound(IEnumerable<(QualifiedMemberName memberName, DeclarationType memberType)> membersNotFound);
     }
 }
diff --git a/Rubberduck.Parsing/Rewriter/MemberAttributeRecoverer.cs b/Rubberduck.Parsing/Rewriter/MemberAttributeRecoverer.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -19,15 +20,17 @@ public sealed class MemberAttributeRecoverer : IMemberAttributeRecovererWithSett
         private IRewritingManager _rewritingManager;
         private readonly IMemberAttributeRecoveryFailureNotifier _failureNotifier;
 
-        private readonly
-            IDictionary<QualifiedModuleName, IDictionary<string, HashSet<AttributeNode>>> _attributesToRecover
-                = new Dictionary<QualifiedModuleName, IDictionary<string, HashSet<AttributeNode>>>();
-        private readonly HashSet<QualifiedMemberName> _missingMembers = new HashSet<QualifiedMemberName>();
+        private readonly IDictionary<QualifiedModuleName, IDictionary<(string memberName, DeclarationType memberType), HashSet<AttributeNode>>> _attributesToRecover
+                = new Dictionary<QualifiedModuleName, IDictionary<(string memberName, DeclarationType memberType), HashSet<AttributeNode>>>();
+        private readonly HashSet<(QualifiedMemberName memberName, DeclarationType memberType)> _missingMembers = new HashSet<(QualifiedMemberName memberName, DeclarationType memberType)>();
 
         private readonly Logger _logger = LogManager.GetCurrentClassLogger();
 
-        public MemberAttributeRecoverer(IDeclarationFinderProvider declarationFinderProvider,
-            IParseManager parseManager, IAttributesUpdater attributesUpdater, IMemberAttributeRecoveryFailureNotifier failureNotifier)
+        public MemberAttributeRecoverer(
+            IDeclarationFinderProvider declarationFinderProvider,
+            IParseManager parseManager, 
+            IAttributesUpdater attributesUpdater, 
+            IMemberAttributeRecoveryFailureNotifier failureNotifier)
         {
             _declarationFinderProvider = declarationFinderProvider;
             _parseManager = parseManager;
@@ -83,7 +86,7 @@ private void SaveAttributesToRecover(IDictionary<QualifiedModuleName, IEnumerabl
                 var attributesByMember = declarationsByModule[module]
                     .Where(decl => decl.Attributes.Any())
                     .ToDictionary(
-                        decl => decl.IdentifierName,
+                        decl => (decl.IdentifierName, decl.DeclarationType),
                         decl => (HashSet<AttributeNode>)decl.Attributes);
                 _attributesToRecover.Add(module, attributesByMember);
             }
@@ -154,41 +157,41 @@ private void CancelTheCurrentParse()
             _parseManager.OnParseCancellationRequested(this);
         }
 
-        private void RecoverAttributes(IRewriteSession rewriteSession, QualifiedModuleName module, IDictionary<string, HashSet<AttributeNode>> attributesByMember)
+        private void RecoverAttributes(IRewriteSession rewriteSession, QualifiedModuleName module, IDictionary<(string memberName, DeclarationType memberType), HashSet<AttributeNode>> attributesByMember)
         {
             var membersWithAttributesToRecover = attributesByMember.Keys.ToHashSet();
             var declarationFinder = _declarationFinderProvider.DeclarationFinder;
             var declarationsWithAttributesToRecover = declarationFinder.Members(module)
-                .Where(decl => membersWithAttributesToRecover.Contains(decl.IdentifierName) 
+                .Where(decl => membersWithAttributesToRecover.Contains((decl.IdentifierName, decl.DeclarationType)) 
                                && decl.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Module))
                 .ToList();
 
             if (membersWithAttributesToRecover.Count != declarationsWithAttributesToRecover.Count)
             {
                 var membersWithoutDeclarations = MembersWithoutDeclarations(membersWithAttributesToRecover, declarationsWithAttributesToRecover);
                 LogFailureToRecoverAllAttributes(module, membersWithoutDeclarations);
-                _missingMembers.UnionWith(membersWithoutDeclarations.Select(memberName => new QualifiedMemberName(module, memberName)));
+                _missingMembers.UnionWith(membersWithoutDeclarations.Select(tpl => (new QualifiedMemberName(module, tpl.memberName), tpl.memberType)));
             }
 
             foreach (var declaration in declarationsWithAttributesToRecover)
             {
-                RecoverAttributes(rewriteSession, declaration, attributesByMember[declaration.IdentifierName]);
+                RecoverAttributes(rewriteSession, declaration, attributesByMember[(declaration.IdentifierName, declaration.DeclarationType)]);
             }
         }
 
-        private static ICollection<string> MembersWithoutDeclarations(HashSet<string> membersWithAttributesToRecover, IEnumerable<Declaration> declarationsWithAttributesToRecover)
+        private static ICollection<(string memberName, DeclarationType memberType)> MembersWithoutDeclarations(HashSet<(string memberName, DeclarationType memberType)> membersWithAttributesToRecover, IEnumerable<Declaration> declarationsWithAttributesToRecover)
         {
             var membersWithoutDeclarations = membersWithAttributesToRecover.ToHashSet();
-            membersWithoutDeclarations.ExceptWith(declarationsWithAttributesToRecover.Select(decl => decl.IdentifierName));
+            membersWithoutDeclarations.ExceptWith(declarationsWithAttributesToRecover.Select(decl => (decl.IdentifierName, decl.DeclarationType)));
             return membersWithoutDeclarations;
         }
 
-        private void LogFailureToRecoverAllAttributes(QualifiedModuleName module, IEnumerable<string> membersWithoutDeclarations)
+        private void LogFailureToRecoverAllAttributes(QualifiedModuleName module, IEnumerable<(string memberName, DeclarationType memberType)> membersWithoutDeclarations)
         {
             _logger.Warn("Could not recover the attributes for all members because one or more members could no longer be found.");
-            foreach (var member in membersWithoutDeclarations)
+            foreach (var (memberName, memberType) in membersWithoutDeclarations)
             {
-                _logger.Trace($"Could not recover the attributes for member {member} in module {module} because a member of that name exists no longer.");
+                _logger.Trace($"Could not recover the attributes for member {memberName} of type {memberType} in module {module} because a member of that name and type exists no longer.");
             }
         }
 
diff --git a/RubberduckTests/Inspections/EmptyModuleInspectionTests.cs b/RubberduckTests/Inspections/EmptyModuleInspectionTests.cs
@@ -49,7 +49,7 @@ Option Explicit
         }
 
         [TestCase("Private Function Foo() As String\r\nEnd Function")]
-        [TestCase("Private Sub Foo() As String\r\nEnd Sub")]
+        [TestCase("Private Sub Foo()\r\nEnd Sub")]
         [TestCase("Public Property Get Foo()\r\nEnd Property")]
         [TestCase("Public Property Set Foo(rhs As Variant)\r\nEnd Property")]
         [TestCase("Public Property Let Foo(rhs As Variant)\r\nEnd Property")]
diff --git a/RubberduckTests/Rewriter/MemberAttributeRecovererTests.cs b/RubberduckTests/Rewriter/MemberAttributeRecovererTests.cs
@@ -250,5 +250,72 @@ Public Function Bar() As Variant
                 Assert.AreEqual(expectedCodeWithoutRecovery, actualCodeWithoutRecovery);
             }
         }
+
+        [Test]
+        [Category("Rewriter")]
+        [TestCase("Attribute Foo.VB_UserMemId = 0", "", "")]
+        [TestCase("", "Attribute Foo.VB_UserMemId = 0", "")]
+        [TestCase("", "", "Attribute Foo.VB_UserMemId = 0")]
+        [TestCase("Attribute Foo.VB_Description = \"myPropertyGet\"", "Attribute Foo.VB_Description = \"myPropertyLet\"", "")]
+        [TestCase("", "Attribute Foo.VB_Description = \"myPropertyLet\"", "Attribute Foo.VB_Description = \"myPropertySet\"")]
+        [TestCase("Attribute Foo.VB_Description = \"myPropertyGet\"", "", "Attribute Foo.VB_Description = \"myPropertySet\"")]
+        [TestCase("Attribute Foo.VB_Description = \"myPropertyGet\"", "Attribute Foo.VB_Description = \"myPropertyLet\"", "Attribute Foo.VB_Description = \"myPropertySet\"")]
+        public void RecoveringAttributesRecoversTheAttributesInTheModulesProvided_ViaModule_PropertiesAreHandlesSeparately(string getAttributes, string letAttributes, string setAttributes)
+        {
+            var inputCode =
+                $@"Public Property Get Foo() As Variant
+{getAttributes}
+End Property
+
+Public Property Let Foo(ByVal RHS As Long)
+{letAttributes}
+End Property
+
+Public Property Set Foo(ByVal RHs As Object)
+{setAttributes}
+End Property";
+
+            var expectedCodeWithRecovery = inputCode;
+
+            var expectedCodeWithoutRecovery =
+                $@"Public Property Get Foo() As Variant{(string.IsNullOrEmpty(getAttributes) ? Environment.NewLine : string.Empty)}
+End Property
+
+Public Property Let Foo(ByVal RHS As Long){(string.IsNullOrEmpty(letAttributes) ? Environment.NewLine : string.Empty)}
+End Property
+
+Public Property Set Foo(ByVal RHs As Object){(string.IsNullOrEmpty(setAttributes) ? Environment.NewLine : string.Empty)}
+End Property";
+
+            var vbe = MockVbeBuilder.BuildFromStdModules(("RecoveryModule", inputCode), ("NoRecoveryModule", inputCode)).Object;
+            var (state, rewritingManager) = MockParser.CreateAndParseWithRewritingManager(vbe);
+            using (state)
+            {
+                var attributesUpdater = new AttributesUpdater(state);
+                var mockFailureNotifier = new Mock<IMemberAttributeRecoveryFailureNotifier>();
+                var memberAttributeRecoverer = new MemberAttributeRecoverer(state, state, attributesUpdater, mockFailureNotifier.Object);
+                memberAttributeRecoverer.RewritingManager = rewritingManager;
+
+                var recoveryModule = state.DeclarationFinder.UserDeclarations(DeclarationType.Module)
+                    .First(decl => decl.IdentifierName.Equals("RecoveryModule")).QualifiedModuleName;
+                var noRecoveryModule = state.DeclarationFinder.UserDeclarations(DeclarationType.Module)
+                    .First(decl => decl.IdentifierName.Equals("NoRecoveryModule")).QualifiedModuleName;
+
+                var modulesToRecoverAttributesIn = new List<QualifiedModuleName> { recoveryModule };
+
+                memberAttributeRecoverer.RecoverCurrentMemberAttributesAfterNextParse(modulesToRecoverAttributesIn);
+
+                var rewriteSession = rewritingManager.CheckOutCodePaneSession();
+                var declarationsForWhichToRemoveAttributes = state.DeclarationFinder.UserDeclarations(DeclarationType.Property);
+                RemoveAttributes(declarationsForWhichToRemoveAttributes, rewriteSession);
+
+                ExecuteAndWaitForParserState(state, () => rewriteSession.TryRewrite(), ParserState.Ready);
+
+                var actualCodeWithRecovery = state.ProjectsProvider.Component(recoveryModule).CodeModule.Content();
+                var actualCodeWithoutRecovery = state.ProjectsProvider.Component(noRecoveryModule).CodeModule.Content();
+                Assert.AreEqual(expectedCodeWithRecovery, actualCodeWithRecovery);
+                Assert.AreEqual(expectedCodeWithoutRecovery, actualCodeWithoutRecovery);
+            }
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,9 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Linq;`
`3`	`4`	`using Rubberduck.Interaction;`
`4`	`5`	`using Rubberduck.Parsing.Rewriter;`
	`6`	`+using Rubberduck.Parsing.Symbols;`
`5`	`7`	`using Rubberduck.VBEditor;`
`6`	`8`
`7`	`9`	`namespace Rubberduck.UI.Notifiers`
`@@ -44,18 +46,19 @@ private static string RewriteFailureReasonMessage(RewriteSessionState sessionSta`
`44`	`46`	`}`
`45`	`47`	`}`
`46`	`48`
`47`		`- public void NotifyMembersForRecoveryNotFound(IEnumerable<QualifiedMemberName> membersNotFound)`
	`49`	`+ public void NotifyMembersForRecoveryNotFound(IEnumerable<(QualifiedMemberName memberName, DeclarationType memberType)> membersNotFound)`
`48`	`50`	`{`
`49`	`51`	`var message = MembersNotFoundMessage(membersNotFound);`
`50`	`52`	`var caption = Resources.RubberduckUI.MemberAttributeRecoveryFailureCaption;`
`51`	`53`
`52`	`54`	`_messageBox.NotifyWarn(message, caption);`
`53`	`55`	`}`
`54`	`56`
`55`		`- private string MembersNotFoundMessage(IEnumerable<QualifiedMemberName> membersNotFound)`
	`57`	`+ private string MembersNotFoundMessage(IEnumerable<(QualifiedMemberName memberName, DeclarationType memberType)> membersNotFound)`
`56`	`58`	`{`
`57`		`- var missingMemberList = $"{Environment.NewLine}{string.Join(Environment.NewLine, membersNotFound)}";`
`58`		`- return string.Format(Resources.RubberduckUI.MemberAttributeRecoveryMembersNotFoundMessage, missingMemberList); ;`
	`59`	`+ var missingMemberTexts = membersNotFound.Select(tpl => $"{tpl.memberName} ({tpl.memberType})");`
	`60`	`+ var missingMemberList = $"{Environment.NewLine}{string.Join(Environment.NewLine, missingMemberTexts)}";`
	`61`	`+ return string.Format(Resources.RubberduckUI.MemberAttributeRecoveryMembersNotFoundMessage, missingMemberList);`
`59`	`62`	`}`
`60`	`63`	`}`
`61`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,12 @@`
`1`	`1`	`using System.Collections.Generic;`
	`2`	`+using Rubberduck.Parsing.Symbols;`
`2`	`3`	`using Rubberduck.VBEditor;`
`3`	`4`
`4`	`5`	`namespace Rubberduck.Parsing.Rewriter`
`5`	`6`	`{`
`6`	`7`	`public interface IMemberAttributeRecoveryFailureNotifier`
`7`	`8`	`{`
`8`	`9`	`void NotifyRewriteFailed(RewriteSessionState rewriteSessionState);`
`9`		`- void NotifyMembersForRecoveryNotFound(IEnumerable<QualifiedMemberName> membersNotFound);`
	`10`	`+ void NotifyMembersForRecoveryNotFound(IEnumerable<(QualifiedMemberName memberName, DeclarationType memberType)> membersNotFound);`
`10`	`11`	`}`
`11`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Diagnostics;`
`3`	`4`	`using System.Linq;`
`4`	`5`	`using System.Threading;`
`5`	`6`	`using System.Threading.Tasks;`
`@@ -19,15 +20,17 @@ public sealed class MemberAttributeRecoverer : IMemberAttributeRecovererWithSett`
`19`	`20`	`private IRewritingManager _rewritingManager;`
`20`	`21`	`private readonly IMemberAttributeRecoveryFailureNotifier _failureNotifier;`
`21`	`22`
`22`		`- private readonly`
`23`		`- IDictionary<QualifiedModuleName, IDictionary<string, HashSet<AttributeNode>>> _attributesToRecover`
`24`		`- = new Dictionary<QualifiedModuleName, IDictionary<string, HashSet<AttributeNode>>>();`
`25`		`- private readonly HashSet<QualifiedMemberName> _missingMembers = new HashSet<QualifiedMemberName>();`
	`23`	`+ private readonly IDictionary<QualifiedModuleName, IDictionary<(string memberName, DeclarationType memberType), HashSet<AttributeNode>>> _attributesToRecover`
	`24`	`+ = new Dictionary<QualifiedModuleName, IDictionary<(string memberName, DeclarationType memberType), HashSet<AttributeNode>>>();`
	`25`	`+ private readonly HashSet<(QualifiedMemberName memberName, DeclarationType memberType)> _missingMembers = new HashSet<(QualifiedMemberName memberName, DeclarationType memberType)>();`
`26`	`26`
`27`	`27`	`private readonly Logger _logger = LogManager.GetCurrentClassLogger();`
`28`	`28`
`29`		`- public MemberAttributeRecoverer(IDeclarationFinderProvider declarationFinderProvider,`
`30`		`- IParseManager parseManager, IAttributesUpdater attributesUpdater, IMemberAttributeRecoveryFailureNotifier failureNotifier)`
	`29`	`+ public MemberAttributeRecoverer(`
	`30`	`+ IDeclarationFinderProvider declarationFinderProvider,`
	`31`	`+ IParseManager parseManager,`
	`32`	`+ IAttributesUpdater attributesUpdater,`
	`33`	`+ IMemberAttributeRecoveryFailureNotifier failureNotifier)`
`31`	`34`	`{`
`32`	`35`	`_declarationFinderProvider = declarationFinderProvider;`
`33`	`36`	`_parseManager = parseManager;`
`@@ -83,7 +86,7 @@ private void SaveAttributesToRecover(IDictionary<QualifiedModuleName, IEnumerabl`
`83`	`86`	`var attributesByMember = declarationsByModule[module]`
`84`	`87`	`.Where(decl => decl.Attributes.Any())`
`85`	`88`	`.ToDictionary(`
`86`		`- decl => decl.IdentifierName,`
	`89`	`+ decl => (decl.IdentifierName, decl.DeclarationType),`
`87`	`90`	`decl => (HashSet<AttributeNode>)decl.Attributes);`
`88`	`91`	`_attributesToRecover.Add(module, attributesByMember);`
`89`	`92`	`}`
`@@ -154,41 +157,41 @@ private void CancelTheCurrentParse()`
`154`	`157`	`_parseManager.OnParseCancellationRequested(this);`
`155`	`158`	`}`
`156`	`159`
`157`		`- private void RecoverAttributes(IRewriteSession rewriteSession, QualifiedModuleName module, IDictionary<string, HashSet<AttributeNode>> attributesByMember)`
	`160`	`+ private void RecoverAttributes(IRewriteSession rewriteSession, QualifiedModuleName module, IDictionary<(string memberName, DeclarationType memberType), HashSet<AttributeNode>> attributesByMember)`
`158`	`161`	`{`
`159`	`162`	`var membersWithAttributesToRecover = attributesByMember.Keys.ToHashSet();`
`160`	`163`	`var declarationFinder = _declarationFinderProvider.DeclarationFinder;`
`161`	`164`	`var declarationsWithAttributesToRecover = declarationFinder.Members(module)`
`162`		`- .Where(decl => membersWithAttributesToRecover.Contains(decl.IdentifierName)`
	`165`	`+ .Where(decl => membersWithAttributesToRecover.Contains((decl.IdentifierName, decl.DeclarationType))`
`163`	`166`	`&& decl.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Module))`
`164`	`167`	`.ToList();`
`165`	`168`
`166`	`169`	`if (membersWithAttributesToRecover.Count != declarationsWithAttributesToRecover.Count)`
`167`	`170`	`{`
`168`	`171`	`var membersWithoutDeclarations = MembersWithoutDeclarations(membersWithAttributesToRecover, declarationsWithAttributesToRecover);`
`169`	`172`	`LogFailureToRecoverAllAttributes(module, membersWithoutDeclarations);`
`170`		`- _missingMembers.UnionWith(membersWithoutDeclarations.Select(memberName => new QualifiedMemberName(module, memberName)));`
	`173`	`+ _missingMembers.UnionWith(membersWithoutDeclarations.Select(tpl => (new QualifiedMemberName(module, tpl.memberName), tpl.memberType)));`
`171`	`174`	`}`
`172`	`175`
`173`	`176`	`foreach (var declaration in declarationsWithAttributesToRecover)`
`174`	`177`	`{`
`175`		`- RecoverAttributes(rewriteSession, declaration, attributesByMember[declaration.IdentifierName]);`
	`178`	`+ RecoverAttributes(rewriteSession, declaration, attributesByMember[(declaration.IdentifierName, declaration.DeclarationType)]);`
`176`	`179`	`}`
`177`	`180`	`}`
`178`	`181`
`179`		`- private static ICollection<string> MembersWithoutDeclarations(HashSet<string> membersWithAttributesToRecover, IEnumerable<Declaration> declarationsWithAttributesToRecover)`
	`182`	`+ private static ICollection<(string memberName, DeclarationType memberType)> MembersWithoutDeclarations(HashSet<(string memberName, DeclarationType memberType)> membersWithAttributesToRecover, IEnumerable<Declaration> declarationsWithAttributesToRecover)`
`180`	`183`	`{`
`181`	`184`	`var membersWithoutDeclarations = membersWithAttributesToRecover.ToHashSet();`
`182`		`- membersWithoutDeclarations.ExceptWith(declarationsWithAttributesToRecover.Select(decl => decl.IdentifierName));`
	`185`	`+ membersWithoutDeclarations.ExceptWith(declarationsWithAttributesToRecover.Select(decl => (decl.IdentifierName, decl.DeclarationType)));`
`183`	`186`	`return membersWithoutDeclarations;`
`184`	`187`	`}`
`185`	`188`
`186`		`- private void LogFailureToRecoverAllAttributes(QualifiedModuleName module, IEnumerable<string> membersWithoutDeclarations)`
	`189`	`+ private void LogFailureToRecoverAllAttributes(QualifiedModuleName module, IEnumerable<(string memberName, DeclarationType memberType)> membersWithoutDeclarations)`
`187`	`190`	`{`
`188`	`191`	`_logger.Warn("Could not recover the attributes for all members because one or more members could no longer be found.");`
`189`		`- foreach (var member in membersWithoutDeclarations)`
	`192`	`+ foreach (var (memberName, memberType) in membersWithoutDeclarations)`
`190`	`193`	`{`
`191`		`- _logger.Trace($"Could not recover the attributes for member {member} in module {module} because a member of that name exists no longer.");`
	`194`	`+ _logger.Trace($"Could not recover the attributes for member {memberName} of type {memberType} in module {module} because a member of that name and type exists no longer.");`
`192`	`195`	`}`
`193`	`196`	`}`
`194`	`197`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ Option Explicit`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`[TestCase("Private Function Foo() As String\r\nEnd Function")]`
`52`		`- [TestCase("Private Sub Foo() As String\r\nEnd Sub")]`
	`52`	`+ [TestCase("Private Sub Foo()\r\nEnd Sub")]`
`53`	`53`	`[TestCase("Public Property Get Foo()\r\nEnd Property")]`
`54`	`54`	`[TestCase("Public Property Set Foo(rhs As Variant)\r\nEnd Property")]`
`55`	`55`	`[TestCase("Public Property Let Foo(rhs As Variant)\r\nEnd Property")]`