Only discover ProjectDisplayName when absolutely necessary.

comintern · comintern · commit 538483695b2d · 2017-01-29T11:36:45.000-06:00
diff --git a/RetailCoder.VBE/Inspections/Abstract/InspectionResultBase.cs b/RetailCoder.VBE/Inspections/Abstract/InspectionResultBase.cs
@@ -87,18 +87,18 @@ public virtual int CompareTo(IInspectionResult other)
             return Inspection.CompareTo(other.Inspection);
         }
 
-        public override string ToString()
-        {
-            var module = QualifiedSelection.QualifiedName;
-            return string.Format(
-                InspectionsUI.QualifiedSelectionInspection,
-                Inspection.Severity,
-                Description,
-                "(" + module.ProjectDisplayName + ")",
-                module.ProjectName,
-                module.ComponentName,
-                QualifiedSelection.Selection.StartLine);
-        }
+        //public override string ToString()
+        //{
+        //    var module = QualifiedSelection.QualifiedName;
+        //    return string.Format(
+        //        InspectionsUI.QualifiedSelectionInspection,
+        //        Inspection.Severity,
+        //        Description,
+        //        "(" + module.ProjectDisplayName + ")",
+        //        module.ProjectName,
+        //        module.ComponentName,
+        //        QualifiedSelection.Selection.StartLine);
+        //}
 
         public virtual NavigateCodeEventArgs GetNavigationArgs()
         {
diff --git a/RetailCoder.VBE/UnitTesting/TestEngine.cs b/RetailCoder.VBE/UnitTesting/TestEngine.cs
@@ -3,11 +3,10 @@
 using System.Diagnostics;
 using System.Linq;
 using Rubberduck.Parsing.Annotations;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.UI.UnitTesting;
-using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.Application;
-using Rubberduck.VBEditor.Extensions;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
 namespace Rubberduck.UnitTesting
@@ -99,7 +98,7 @@ public void Run(IEnumerable<TestMethod> tests)
             }
         }
 
-        private void Run(IEnumerable<QualifiedMemberName> members)
+        private void Run(IEnumerable<Declaration> members)
         {
             if (_hostApplication == null)
             {
diff --git a/RetailCoder.VBE/UnitTesting/TestMethod.cs b/RetailCoder.VBE/UnitTesting/TestMethod.cs
@@ -44,7 +44,7 @@ public void Run()
             try
             {
                 AssertHandler.OnAssertCompleted += HandleAssertCompleted;
-                _hostApp.Run(Declaration.QualifiedName);
+                _hostApp.Run(Declaration);
                 AssertHandler.OnAssertCompleted -= HandleAssertCompleted;
                 
                 result = EvaluateResults();
diff --git a/RetailCoder.VBE/UnitTesting/UnitTestUtils.cs b/RetailCoder.VBE/UnitTesting/UnitTestUtils.cs
@@ -38,40 +38,36 @@ public static bool IsTestMethod(RubberduckParserState state, Declaration item)
                 item.Annotations.Any(a => a.AnnotationType == AnnotationType.TestMethod);
         }
 
-        public static IEnumerable<QualifiedMemberName> FindModuleInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)
+        public static IEnumerable<Declaration> FindModuleInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)
         {
             return GetTestModuleProcedures(state)
                     .Where(m =>
                             m.QualifiedName.QualifiedModuleName == module &&
-                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleInitialize))
-                    .Select(s => s.QualifiedName);
+                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleInitialize));
         }
 
-        public static IEnumerable<QualifiedMemberName> FindModuleCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)
+        public static IEnumerable<Declaration> FindModuleCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)
         {
             return GetTestModuleProcedures(state)
                     .Where(m =>
                             m.QualifiedName.QualifiedModuleName == module &&
-                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleCleanup))
-                    .Select(s => s.QualifiedName);
+                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleCleanup));
         }
 
-        public static IEnumerable<QualifiedMemberName> FindTestInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)
+        public static IEnumerable<Declaration> FindTestInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)
         {
             return GetTestModuleProcedures(state)
                     .Where(m =>
                             m.QualifiedName.QualifiedModuleName == module &&
-                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestInitialize))
-                    .Select(s => s.QualifiedName);
+                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestInitialize));
         }
 
-        public static IEnumerable<QualifiedMemberName> FindTestCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)
+        public static IEnumerable<Declaration> FindTestCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)
         {
             return GetTestModuleProcedures(state)
                     .Where(m =>
                             m.QualifiedName.QualifiedModuleName == module &&
-                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestCleanup))
-                    .Select(s => s.QualifiedName);
+                            m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestCleanup));
         }
 
         private static IEnumerable<Declaration> GetTestModuleProcedures(RubberduckParserState state)
diff --git a/Rubberduck.Parsing/Symbols/Declaration.cs b/Rubberduck.Parsing/Symbols/Declaration.cs
@@ -424,6 +424,12 @@ public string ProjectName
             get { return _projectName; }
         }
 
+        /// <summary>
+        /// WARNING: This property has side effects. It changes the ActiveVBProject, which causes a flicker in the VBE.
+        /// This should only be called if it is *absolutely* necessary.
+        /// </summary>
+        public virtual string ProjectDisplayName { get { return _parentDeclaration.ProjectDisplayName; } }
+
         public object[] ToArray()
         {
             return new object[] { ProjectName, CustomFolder, ComponentName, DeclarationType.ToString(), Scope, IdentifierName, AsTypeName };
diff --git a/Rubberduck.Parsing/Symbols/ProjectDeclaration.cs b/Rubberduck.Parsing/Symbols/ProjectDeclaration.cs
@@ -1,4 +1,5 @@
-﻿using Rubberduck.Parsing.ComReflection;
+﻿using System.Text.RegularExpressions;
+using Rubberduck.Parsing.ComReflection;
 using Rubberduck.VBEditor;
 using System.Collections.Generic;
 using System.Linq;
@@ -70,5 +71,57 @@ public void AddProjectReference(string referencedProjectId, int priority)
             }
             _projectReferences.Add(new ProjectReference(referencedProjectId, priority));
         }
+
+        private static readonly Regex CaptionProjectRegex = new Regex(@"^(?:[^-]+)(?:\s-\s)(?<project>.+)(?:\s-\s.*)?$");
+        private static readonly Regex OpenModuleRegex = new Regex(@"^(?<project>.+)(?<module>\s-\s\[.*\((Code|UserForm)\)\])$");
+
+        private string _displayName;
+        /// <summary>
+        /// WARNING: This property has side effects. It changes the ActiveVBProject, which causes a flicker in the VBE.
+        /// This should only be called if it is *absolutely* necessary.
+        /// </summary>
+        public override string ProjectDisplayName
+        {
+            get
+            {
+                if (_displayName != null)
+                {
+                    return _displayName;
+                }
+
+                if (_project == null)
+                {
+                    _displayName = string.Empty;
+                    return _displayName;
+                }
+
+                var vbe = _project.VBE;
+                var activeProject = vbe.ActiveVBProject;
+                var mainWindow = vbe.MainWindow;
+                {
+                    try
+                    {
+                        if (_project.HelpFile != activeProject.HelpFile)
+                        {
+                            vbe.ActiveVBProject = _project;
+                        }
+
+                        var caption = mainWindow.Caption;
+                        if (CaptionProjectRegex.IsMatch(caption))
+                        {
+                            caption = CaptionProjectRegex.Matches(caption)[0].Groups["project"].Value;
+                            _displayName = OpenModuleRegex.IsMatch(caption)
+                                ? OpenModuleRegex.Matches(caption)[0].Groups["project"].Value
+                                : caption;
+                        }
+                    }
+                    catch
+                    {
+                        _displayName = string.Empty;
+                    }
+                    return _displayName;
+                }
+            }
+        }
     }
 }
diff --git a/Rubberduck.VBEEditor/Application/AccessApp.cs b/Rubberduck.VBEEditor/Application/AccessApp.cs
@@ -11,8 +11,9 @@ public class AccessApp : HostApplicationBase<Microsoft.Office.Interop.Access.App
     {
         public AccessApp() : base("Access") { }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
+            var qualifiedMemberName = declaration.QualifiedName;
             var call = GenerateMethodCall(qualifiedMemberName);
             Application.Run(call);
         }
diff --git a/Rubberduck.VBEEditor/Application/AutoCADApp.cs b/Rubberduck.VBEEditor/Application/AutoCADApp.cs
@@ -4,9 +4,9 @@ public class AutoCADApp : HostApplicationBase<Autodesk.AutoCAD.Interop.AcadAppli
     {
         public AutoCADApp() : base("AutoCAD") { }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
-            Application.RunMacro(qualifiedMemberName.ToString());
+            Application.RunMacro(declaration.QualifiedName.ToString());
         }
     }
 }
diff --git a/Rubberduck.VBEEditor/Application/CorelDRAWApp.cs b/Rubberduck.VBEEditor/Application/CorelDRAWApp.cs
@@ -12,9 +12,10 @@ public CorelDRAWApp(IVBE vbe) : base(vbe, "CorelDRAW") { }
 
         //TODO:RunMacro can only execute methods in stand-alone projects (not document hosted projects)
         //TODO:Can only get a CorelDraw application if at least one document is open in CorelDraw.
-		
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+
+        public override void Run(dynamic declaration)
         {
+            var qualifiedMemberName = declaration.QualifiedName;
             var projectName = qualifiedMemberName.QualifiedModuleName.ProjectName;
             var memberName = qualifiedMemberName.QualifiedModuleName.ComponentName + "." + qualifiedMemberName.MemberName;
 
diff --git a/Rubberduck.VBEEditor/Application/ExcelApp.cs b/Rubberduck.VBEEditor/Application/ExcelApp.cs
@@ -8,18 +8,19 @@ public class ExcelApp : HostApplicationBase<Microsoft.Office.Interop.Excel.Appli
         public ExcelApp() : base("Excel") { }
         public ExcelApp(IVBE vbe) : base(vbe, "Excel") { }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
-            var call = GenerateMethodCall(qualifiedMemberName);
+            var call = GenerateMethodCall(declaration);
             Application.Run(call);
         }
 
-        protected virtual string GenerateMethodCall(QualifiedMemberName qualifiedMemberName)
+        protected virtual string GenerateMethodCall(dynamic declaration)
         {
+            var qualifiedMemberName = declaration.QualifiedName;
             var module = qualifiedMemberName.QualifiedModuleName;
 
             var documentName = string.IsNullOrEmpty(module.ProjectPath)
-                ? module.ProjectDisplayName
+                ? declaration.ProjectDisplayName
                 : Path.GetFileName(module.ProjectPath);
 
             return string.IsNullOrEmpty(documentName)
diff --git a/Rubberduck.VBEEditor/Application/FallbackApp.cs b/Rubberduck.VBEEditor/Application/FallbackApp.cs
@@ -19,8 +19,9 @@ public FallbackApp(IVBE vbe)
             _runButton = (ICommandBarButton)mainCommandBar.FindControl(RunMacroCommand);
         }
 
-        public void Run(QualifiedMemberName qualifiedMemberName)
+        public void Run(dynamic declaration)
         {
+            var qualifiedMemberName = declaration.QualifiedName;
             var component = qualifiedMemberName.QualifiedModuleName.Component;
             var module = component.CodeModule;
             {
@@ -35,11 +36,11 @@ public void Run(QualifiedMemberName qualifiedMemberName)
             // note: this can't work... because the .Execute() call isn't blocking, so method returns before test method actually runs.
         }
 
-        public TimeSpan TimedMethodCall(QualifiedMemberName qualifiedMemberName)
+        public TimeSpan TimedMethodCall(dynamic declaration)
         {
             var stopwatch = Stopwatch.StartNew();
 
-            Run(qualifiedMemberName);
+            Run(declaration);
 
             stopwatch.Stop();
             return stopwatch.Elapsed;
diff --git a/Rubberduck.VBEEditor/Application/HostApplicationBase.cs b/Rubberduck.VBEEditor/Application/HostApplicationBase.cs
@@ -65,7 +65,7 @@ public string ApplicationName
             get { return _applicationName; }
         }
 
-        public abstract void Run(QualifiedMemberName qualifiedMemberName);
+        public abstract void Run(dynamic declaration);
 
         public void Dispose()
         {
diff --git a/Rubberduck.VBEEditor/Application/IHostApplication.cs b/Rubberduck.VBEEditor/Application/IHostApplication.cs
@@ -5,10 +5,11 @@ namespace Rubberduck.VBEditor.Application
     public interface IHostApplication : IDisposable
     {
         /// <summary>
-        /// Runs VBA procedure specified by name.
+        /// Runs VBA procedure specified by name. WARNING: The parameter is declared as dynamic to prevent circular referencing.
+        /// This should ONLY be passed a Declaration object.
         /// </summary>
-        /// <param name="qualifiedMemberName">The method to be executed.</param>
-        void Run(QualifiedMemberName qualifiedMemberName);
+        /// <param name="declaration">The Declaration object for the method to be executed.</param>
+        void Run(dynamic declaration);
 
         /// <summary>
         /// Gets the name of the application.
diff --git a/Rubberduck.VBEEditor/Application/OutlookApp.cs b/Rubberduck.VBEEditor/Application/OutlookApp.cs
@@ -10,7 +10,7 @@ public OutlookApp() : base("Outlook")
         {
         }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
             // note: does not work. http://stackoverflow.com/q/31954364/1188513
             //var app = Application.GetType();
@@ -28,7 +28,7 @@ public override void Run(QualifiedMemberName qualifiedMemberName)
                 var exp = app.ActiveExplorer();
                 CommandBar cb = exp.CommandBars.Add("RubberduckCallbackProxy", Temporary: true);
                 CommandBarControl btn = cb.Controls.Add(MsoControlType.msoControlButton, 1);
-                btn.OnAction = qualifiedMemberName.ToString();
+                btn.OnAction = declaration.QualifiedName.ToString();
                 btn.Execute();
                 cb.Delete();
             }
diff --git a/Rubberduck.VBEEditor/Application/PowerPointApp.cs b/Rubberduck.VBEEditor/Application/PowerPointApp.cs
@@ -4,9 +4,9 @@ public class PowerPointApp : HostApplicationBase<Microsoft.Office.Interop.PowerP
     {
         public PowerPointApp() : base("PowerPoint") { }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
-            var methodCall = GenerateMethodCall(qualifiedMemberName);
+            var methodCall = GenerateMethodCall(declaration.QualifiedName);
             if (methodCall == null) { return; }
 
             //PowerPoint requires a paramarray, so we pass it an empty array:
diff --git a/Rubberduck.VBEEditor/Application/ProjectApp.cs b/Rubberduck.VBEEditor/Application/ProjectApp.cs
@@ -7,9 +7,9 @@ public class ProjectApp : HostApplicationBase<Microsoft.Office.Interop.MSProject
         public ProjectApp() : base("MSProject") { }
         public ProjectApp(IVBE vbe) : base(vbe, "MSProject") { }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
-            var call = GenerateMethodCall(qualifiedMemberName);
+            var call = GenerateMethodCall(declaration.QualifiedName);
             Application.Macro(call);
         }
 
diff --git a/Rubberduck.VBEEditor/Application/PublisherApp.cs b/Rubberduck.VBEEditor/Application/PublisherApp.cs
@@ -6,7 +6,7 @@ public class PublisherApp : HostApplicationBase<Microsoft.Office.Interop.Publish
     {
         public PublisherApp() : base("Publisher") { }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
             //Publisher does not support the Run method
             throw new NotImplementedException("Unit Testing not supported for Publisher");
diff --git a/Rubberduck.VBEEditor/Application/SolidWorksApp.cs b/Rubberduck.VBEEditor/Application/SolidWorksApp.cs
@@ -7,9 +7,10 @@ public class SolidWorksApp : HostApplicationBase<Interop.SldWorks.Extensibility.
     {
         public SolidWorksApp() : base("SolidWorks") { }
         public SolidWorksApp(IVBE vbe) : base(vbe, "SolidWorks") { }
-		
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+
+        public override void Run(dynamic declaration)
         {
+            var qualifiedMemberName = declaration.QualifiedName;
             var projectFileName = qualifiedMemberName.QualifiedModuleName.ProjectPath;
             if (Application == null || string.IsNullOrEmpty(projectFileName)) { return; }
 
diff --git a/Rubberduck.VBEEditor/Application/Visio.cs b/Rubberduck.VBEEditor/Application/Visio.cs
@@ -7,12 +7,12 @@ public class VisioApp : HostApplicationBase<Microsoft.Office.Interop.Visio.Appli
         public VisioApp() : base("Visio") { }
         public VisioApp(IVBE vbe) : base(vbe, "Visio") { }
 
-        public override void Run(QualifiedMemberName qualifiedMemberName)
+        public override void Run(dynamic declaration)
         {
             try
             {
-                Microsoft.Office.Interop.Visio.Document doc = Application.Documents[qualifiedMemberName.QualifiedModuleName.ProjectDisplayName];
-                var call = GenerateMethodCall(qualifiedMemberName);
+                Microsoft.Office.Interop.Visio.Document doc = Application.Documents[declaration.ProjectDisplayName];
+                var call = GenerateMethodCall(declaration.QualifiedName);
                 doc.ExecuteLine(call);
             }
             catch 
diff --git a/Rubberduck.VBEEditor/Application/WordApp.cs b/Rubberduck.VBEEditor/Application/WordApp.cs
diff --git a/Rubberduck.VBEEditor/QualifiedModuleName.cs b/Rubberduck.VBEEditor/QualifiedModuleName.cs
diff --git a/RubberduckTests/UnitTesting/DiscoveryTests.cs b/RubberduckTests/UnitTesting/DiscoveryTests.cs

Original file line number	Diff line number	Diff line change
`@@ -3,11 +3,10 @@`
`3`	`3`	`using System.Diagnostics;`
`4`	`4`	`using System.Linq;`
`5`	`5`	`using Rubberduck.Parsing.Annotations;`
	`6`	`+using Rubberduck.Parsing.Symbols;`
`6`	`7`	`using Rubberduck.Parsing.VBA;`
`7`	`8`	`using Rubberduck.UI.UnitTesting;`
`8`		`-using Rubberduck.VBEditor;`
`9`	`9`	`using Rubberduck.VBEditor.Application;`
`10`		`-using Rubberduck.VBEditor.Extensions;`
`11`	`10`	`using Rubberduck.VBEditor.SafeComWrappers.Abstract;`
`12`	`11`
`13`	`12`	`namespace Rubberduck.UnitTesting`
`@@ -99,7 +98,7 @@ public void Run(IEnumerable<TestMethod> tests)`
`99`	`98`	`}`
`100`	`99`	`}`
`101`	`100`
`102`		`- private void Run(IEnumerable<QualifiedMemberName> members)`
	`101`	`+ private void Run(IEnumerable<Declaration> members)`
`103`	`102`	`{`
`104`	`103`	`if (_hostApplication == null)`
`105`	`104`	`{`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public void Run()`
`44`	`44`	`try`
`45`	`45`	`{`
`46`	`46`	`AssertHandler.OnAssertCompleted += HandleAssertCompleted;`
`47`		`- _hostApp.Run(Declaration.QualifiedName);`
	`47`	`+ _hostApp.Run(Declaration);`
`48`	`48`	`AssertHandler.OnAssertCompleted -= HandleAssertCompleted;`
`49`	`49`
`50`	`50`	`result = EvaluateResults();`
Original file line number	Diff line number	Diff line change
`@@ -38,40 +38,36 @@ public static bool IsTestMethod(RubberduckParserState state, Declaration item)`
`38`	`38`	`item.Annotations.Any(a => a.AnnotationType == AnnotationType.TestMethod);`
`39`	`39`	`}`
`40`	`40`
`41`		`- public static IEnumerable<QualifiedMemberName> FindModuleInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)`
	`41`	`+ public static IEnumerable<Declaration> FindModuleInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)`
`42`	`42`	`{`
`43`	`43`	`return GetTestModuleProcedures(state)`
`44`	`44`	`.Where(m =>`
`45`	`45`	`m.QualifiedName.QualifiedModuleName == module &&`
`46`		`- m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleInitialize))`
`47`		`- .Select(s => s.QualifiedName);`
	`46`	`+ m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleInitialize));`
`48`	`47`	`}`
`49`	`48`
`50`		`- public static IEnumerable<QualifiedMemberName> FindModuleCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)`
	`49`	`+ public static IEnumerable<Declaration> FindModuleCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)`
`51`	`50`	`{`
`52`	`51`	`return GetTestModuleProcedures(state)`
`53`	`52`	`.Where(m =>`
`54`	`53`	`m.QualifiedName.QualifiedModuleName == module &&`
`55`		`- m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleCleanup))`
`56`		`- .Select(s => s.QualifiedName);`
	`54`	`+ m.Annotations.Any(a => a.AnnotationType == AnnotationType.ModuleCleanup));`
`57`	`55`	`}`
`58`	`56`
`59`		`- public static IEnumerable<QualifiedMemberName> FindTestInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)`
	`57`	`+ public static IEnumerable<Declaration> FindTestInitializeMethods(this QualifiedModuleName module, RubberduckParserState state)`
`60`	`58`	`{`
`61`	`59`	`return GetTestModuleProcedures(state)`
`62`	`60`	`.Where(m =>`
`63`	`61`	`m.QualifiedName.QualifiedModuleName == module &&`
`64`		`- m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestInitialize))`
`65`		`- .Select(s => s.QualifiedName);`
	`62`	`+ m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestInitialize));`
`66`	`63`	`}`
`67`	`64`
`68`		`- public static IEnumerable<QualifiedMemberName> FindTestCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)`
	`65`	`+ public static IEnumerable<Declaration> FindTestCleanupMethods(this QualifiedModuleName module, RubberduckParserState state)`
`69`	`66`	`{`
`70`	`67`	`return GetTestModuleProcedures(state)`
`71`	`68`	`.Where(m =>`
`72`	`69`	`m.QualifiedName.QualifiedModuleName == module &&`
`73`		`- m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestCleanup))`
`74`		`- .Select(s => s.QualifiedName);`
	`70`	`+ m.Annotations.Any(a => a.AnnotationType == AnnotationType.TestCleanup));`
`75`	`71`	`}`
`76`	`72`
`77`	`73`	`private static IEnumerable<Declaration> GetTestModuleProcedures(RubberduckParserState state)`
Original file line number	Diff line number	Diff line change
`@@ -424,6 +424,12 @@ public string ProjectName`
`424`	`424`	`get { return _projectName; }`
`425`	`425`	`}`
`426`	`426`
	`427`	`+ /// <summary>`
	`428`	`+ /// WARNING: This property has side effects. It changes the ActiveVBProject, which causes a flicker in the VBE.`
	`429`	`+ /// This should only be called if it is absolutely necessary.`
	`430`	`+ /// </summary>`
	`431`	`+ public virtual string ProjectDisplayName { get { return _parentDeclaration.ProjectDisplayName; } }`
	`432`	`+`
`427`	`433`	`public object[] ToArray()`
`428`	`434`	`{`
`429`	`435`	`return new object[] { ProjectName, CustomFolder, ComponentName, DeclarationType.ToString(), Scope, IdentifierName, AsTypeName };`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,9 @@ public class AccessApp : HostApplicationBase<Microsoft.Office.Interop.Access.App`
`11`	`11`	`{`
`12`	`12`	`public AccessApp() : base("Access") { }`
`13`	`13`
`14`		`- public override void Run(QualifiedMemberName qualifiedMemberName)`
	`14`	`+ public override void Run(dynamic declaration)`
`15`	`15`	`{`
	`16`	`+ var qualifiedMemberName = declaration.QualifiedName;`
`16`	`17`	`var call = GenerateMethodCall(qualifiedMemberName);`
`17`	`18`	`Application.Run(call);`
`18`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,9 @@ public class AutoCADApp : HostApplicationBase<Autodesk.AutoCAD.Interop.AcadAppli`
`4`	`4`	`{`
`5`	`5`	`public AutoCADApp() : base("AutoCAD") { }`
`6`	`6`
`7`		`- public override void Run(QualifiedMemberName qualifiedMemberName)`
	`7`	`+ public override void Run(dynamic declaration)`
`8`	`8`	`{`
`9`		`- Application.RunMacro(qualifiedMemberName.ToString());`
	`9`	`+ Application.RunMacro(declaration.QualifiedName.ToString());`
`10`	`10`	`}`
`11`	`11`	`}`
`12`	`12`	`}`