sync with main repo / fix merge conflicts

retailcoder · retailcoder · commit 349029710797 · 2017-03-09T01:06:45.000-05:00
diff --git a/Rubberduck.Parsing/Symbols/DeclarationFinder.cs b/Rubberduck.Parsing/Symbols/DeclarationFinder.cs
@@ -55,8 +55,11 @@ public class DeclarationFinder
         private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _handlersByWithEventsField;
         private readonly Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>> _membersByImplementsContext;
         private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _interfaceMembers;
+        private Lazy<List<Declaration>> _nonBaseAsType;
+        private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers;
+        private readonly Lazy<ConcurrentBag<Declaration>> _classes;
         
-        private static readonly object ThreadLock = new object();
+        private readonly object threadLock = new object();
 
         private static QualifiedSelection GetGroupingKey(Declaration declaration)
         {
@@ -153,8 +156,16 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA
                 });
 
             _membersByImplementsContext = new Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>>(() =>
-            new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(
-                implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);
+                new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(
+                    implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);
+
+            _nonBaseAsType = new Lazy<List<Declaration>>(() =>
+                            _declarations.AllValues().Where(d =>
+                            !string.IsNullOrWhiteSpace(d.AsTypeName)
+                            && !d.AsTypeIsBaseType
+                            && d.DeclarationType != DeclarationType.Project
+                            && d.DeclarationType != DeclarationType.ProceduralModule).ToList()
+                            ,true);
         }
 
         public Declaration FindSelectedDeclaration(ICodePane activeCodePane)
@@ -228,38 +239,22 @@ public IEnumerable<Declaration> Members(QualifiedModuleName module)
             return _declarations[module];
         }
 
-        private IEnumerable<Declaration> _nonBaseAsType;
         public IEnumerable<Declaration> FindDeclarationsWithNonBaseAsType()
         {
-            lock (ThreadLock)
-            {
-                return _nonBaseAsType ?? (_nonBaseAsType = _declarations.AllValues().Where(d =>
-                            !string.IsNullOrWhiteSpace(d.AsTypeName)
-                            && !d.AsTypeIsBaseType
-                            && d.DeclarationType != DeclarationType.Project
-                            && d.DeclarationType != DeclarationType.ProceduralModule).ToList());
-            }
-        }
+            return _nonBaseAsType.Value;
 
-        private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers; 
+        }
+ 
         public IEnumerable<Declaration> FindEventHandlers()
         {
-            lock (ThreadLock)
-            {
-                return _eventHandlers.Value;
-            }
+            return _eventHandlers.Value;
         }
 
-        private readonly Lazy<ConcurrentBag<Declaration>> _classes;
-
         public IEnumerable<Declaration> Classes
         {
             get
             {
-                lock (ThreadLock)
-                {
-                    return _classes.Value;
-                }
+                return _classes.Value;
             }
         }
 
@@ -269,10 +264,7 @@ public IEnumerable<Declaration> Projects
         {
             get
             {
-                lock (ThreadLock)
-                {
-                    return _projects.Value;
-                }
+                return _projects.Value;
             }
         }
 
@@ -290,10 +282,7 @@ public IEnumerable<Declaration> UserDeclarations(DeclarationType type)
 
         public IEnumerable<UnboundMemberDeclaration> FreshUnresolvedMemberDeclarations()
         {
-            lock (ThreadLock)
-            {
-                return _newUnresolved.ToArray();
-            }            
+            return _newUnresolved.ToArray(); //This does not need a lock because enumerators over a ConcurrentBag uses a snapshot.           
         }
 
         public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()
@@ -338,19 +327,18 @@ public Declaration FindParameter(Declaration procedure, string parameterName)
         public IEnumerable<Declaration> FindMemberMatches(Declaration parent, string memberName)
         {
             ConcurrentBag<Declaration> children;
-            if (_declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children))
-            {
-                return children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)
-                                             && item.IdentifierName == memberName).ToList();
-            }
-
-            return Enumerable.Empty<Declaration>();
+            return _declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children)
+                ? children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)
+                                             && item.IdentifierName == memberName).ToList()
+                : Enumerable.Empty<Declaration>();
         }
 
         public IEnumerable<IAnnotation> FindAnnotations(QualifiedModuleName module)
         {
             ConcurrentBag<IAnnotation> result;
-            return _annotations.TryGetValue(module, out result) ? result : Enumerable.Empty<IAnnotation>();
+            return _annotations.TryGetValue(module, out result) 
+                ? result 
+                : Enumerable.Empty<IAnnotation>();
         }
 
         public bool IsMatch(string declarationName, string potentialMatchName)
@@ -405,7 +393,8 @@ public Declaration FindProject(string name, Declaration currentScope = null)
             Declaration result = null;
             try
             {
-                result = MatchName(name).SingleOrDefault(project => project.DeclarationType.HasFlag(DeclarationType.Project)
+                result = MatchName(name).SingleOrDefault(project => 
+                    project.DeclarationType.HasFlag(DeclarationType.Project)
                     && (currentScope == null || project.ProjectId == currentScope.ProjectId));
             }
             catch (InvalidOperationException exception)
@@ -416,7 +405,7 @@ public Declaration FindProject(string name, Declaration currentScope = null)
             return result;
         }
 
-        public Declaration FindStdModule(string name, Declaration parent = null, bool includeBuiltIn = false)
+        public Declaration FindStdModule(string name, Declaration parent, bool includeBuiltIn = false)
         {
             Debug.Assert(parent != null);
             Declaration result = null;
@@ -435,7 +424,7 @@ public Declaration FindStdModule(string name, Declaration parent = null, bool in
             return result;
         }
 
-        public Declaration FindClassModule(string name, Declaration parent = null, bool includeBuiltIn = false)
+        public Declaration FindClassModule(string name, Declaration parent, bool includeBuiltIn = false)
         {
             Debug.Assert(parent != null);
             Declaration result = null;
diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs
@@ -704,6 +704,10 @@ private void ParseAllInternal(object requestor, CancellationToken token)
         {
                 token.ThrowIfCancellationRequested();
 
+            Thread.Sleep(50); //Simplistic hack to give the VBE time to do its work in case the parsing run is requested from an event handler. 
+
+                token.ThrowIfCancellationRequested();
+
             State.RefreshProjects(_vbe);
 
                 token.ThrowIfCancellationRequested();
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -1072,12 +1072,13 @@ public HashSet<QualifiedModuleName> ModulesReferencedBy(QualifiedModuleName refe
 
         public HashSet<QualifiedModuleName> ModulesReferencedBy(IEnumerable<QualifiedModuleName> referencingModules)
         {
-            var referencedModules = new HashSet<QualifiedModuleName>();
+            var toModules = new HashSet<QualifiedModuleName>();
+
             foreach (var referencingModule in referencingModules)
             {
-                referencedModules.UnionWith(ModulesReferencedBy(referencingModule));
+                toModules.UnionWith(ModulesReferencedBy(referencingModule));
             }
-            return referencedModules;
+            return toModules;
         }
 
         public HashSet<QualifiedModuleName> ModulesReferencing(QualifiedModuleName referencedModule)
diff --git a/Rubberduck.VBEEditor/Events/VBENativeServices.cs b/Rubberduck.VBEEditor/Events/VBENativeServices.cs
@@ -170,12 +170,27 @@ private static void OnWindowFocusChange(object sender, WindowChangedEventArgs ev
 
         private static ICodePane GetCodePaneFromHwnd(IntPtr hwnd)
         {
-            var caption = hwnd.GetWindowText();
-            return _vbe.CodePanes.FirstOrDefault(x => x.Window.Caption.Equals(caption));
+            try
+            {
+                var caption = hwnd.GetWindowText();
+                return _vbe.CodePanes.FirstOrDefault(x => x.Window.Caption.Equals(caption));
+            }
+            catch
+            {
+                // This *should* only happen when a code pane window is removed and RD responds faster than
+                // the VBE removes it from the windows collection. TODO: Find a better method to match code panes
+                // to windows than testing the captions.
+                return null;
+            }
         }
 
         private static IWindow GetWindowFromHwnd(IntPtr hwnd)
         {
+            if (!User32.IsWindow(hwnd))
+            {
+                return null;
+            }
+
             var caption = hwnd.GetWindowText();
             return _vbe.Windows.FirstOrDefault(x => x.Caption.Equals(caption));
         }
diff --git a/Rubberduck.VBEEditor/WindowsApi/User32.cs b/Rubberduck.VBEEditor/WindowsApi/User32.cs
@@ -82,5 +82,14 @@ public static class User32
 
         [DllImport("user32.dll", CharSet = CharSet.Unicode)]
         internal static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string lclassName, string windowTitle);
+
+        /// <summary>
+        /// Validates a window handle.
+        /// </summary>
+        /// <param name="hWnd">The handle to validate.</param>
+        /// <returns></returns>
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool IsWindow(IntPtr hWnd);
     }
 }
diff --git a/RubberduckTests/Symbols/DeclarationFinderTests.cs b/RubberduckTests/Symbols/DeclarationFinderTests.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+﻿using System.Linq;
 using System.Threading;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Rubberduck.Parsing.Symbols;
@@ -67,5 +67,59 @@ End Sub
 
             Assert.AreEqual(expected, actual, "Expected {0}, resolved to {1}", expected.DeclarationType, actual.DeclarationType);
         }
+
+        [TestCategory("Resolver")]
+        [TestMethod]
+        public void DeclarationFinderCanCopeWithMultipleModulesImplementingTheSameInterface()
+        {
+            var project = GetTestProject("testProject");
+            var interf = GetTestClassModule(project, "interface");
+            var member = GetTestFunction(interf, "testMember", Accessibility.Public);
+            var implementingClass1 = GetTestClassModule(project, "implementingClass1");
+            var implementingClass2 = GetTestClassModule(project, "implementingClass2");
+            var implementsContext1 = new VBAParser.ImplementsStmtContext(null, 0);
+            var implementsContext2 = new VBAParser.ImplementsStmtContext(null, 0);
+            AddReference(interf, implementingClass1, implementsContext1);
+            AddReference(interf, implementingClass1, implementsContext2);
+            var declarations = new List<Declaration> { interf, member, implementingClass1, implementingClass2 };
+
+            DeclarationFinder finder = new DeclarationFinder(declarations, new List<Rubberduck.Parsing.Annotations.IAnnotation>(), new List<UnboundMemberDeclaration>());
+            var interfaceDeclarations = finder.FindAllInterfaceMembers().ToList();
+
+            Assert.AreEqual(1, interfaceDeclarations.Count());
+        }
+
+        private static ClassModuleDeclaration GetTestClassModule(Declaration projectDeclatation, string name, bool isExposed = false)
+        {
+            var qualifiedClassModuleMemberName = new QualifiedMemberName(StubQualifiedModuleName(name), name);
+            var classModuleAttributes = new Rubberduck.Parsing.VBA.Attributes();
+            if (isExposed)
+            {
+                classModuleAttributes.AddExposedClassAttribute();
+            }
+            return new ClassModuleDeclaration(qualifiedClassModuleMemberName, projectDeclatation, name, false, null, classModuleAttributes);
+        }
+
+        private static ProjectDeclaration GetTestProject(string name)
+        {
+            var qualifiedProjectName = new QualifiedMemberName(StubQualifiedModuleName("proj"), name);
+            return new ProjectDeclaration(qualifiedProjectName, name, false, null);
+        }
+
+        private static QualifiedModuleName StubQualifiedModuleName(string name)
+        {
+            return new QualifiedModuleName("dummy", "dummy", name);
+        }
+
+        private static FunctionDeclaration GetTestFunction(Declaration moduleDeclatation, string name, Accessibility functionAccessibility)
+        {
+            var qualifiedFunctionMemberName = new QualifiedMemberName(moduleDeclatation.QualifiedName.QualifiedModuleName, name);
+            return new FunctionDeclaration(qualifiedFunctionMemberName, moduleDeclatation, moduleDeclatation, "test", null, "test", functionAccessibility, null, Selection.Home, false, false, null, null);
+        }
+
+        private static void AddReference(Declaration toDeclaration, Declaration fromModuleDeclaration, ParserRuleContext context = null)
+        {
+            toDeclaration.AddReference(toDeclaration.QualifiedName.QualifiedModuleName, fromModuleDeclaration, fromModuleDeclaration, context, toDeclaration.IdentifierName, toDeclaration, Selection.Home, new List<Rubberduck.Parsing.Annotations.IAnnotation>());
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -55,8 +55,11 @@ public class DeclarationFinder`
`55`	`55`	`private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _handlersByWithEventsField;`
`56`	`56`	`private readonly Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>> _membersByImplementsContext;`
`57`	`57`	`private readonly Lazy<ConcurrentDictionary<Declaration, Declaration[]>> _interfaceMembers;`
	`58`	`+ private Lazy<List<Declaration>> _nonBaseAsType;`
	`59`	`+ private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers;`
	`60`	`+ private readonly Lazy<ConcurrentBag<Declaration>> _classes;`
`58`	`61`
`59`		`- private static readonly object ThreadLock = new object();`
	`62`	`+ private readonly object threadLock = new object();`
`60`	`63`
`61`	`64`	`private static QualifiedSelection GetGroupingKey(Declaration declaration)`
`62`	`65`	`{`
`@@ -153,8 +156,16 @@ public DeclarationFinder(IReadOnlyList<Declaration> declarations, IEnumerable<IA`
`153`	`156`	`});`
`154`	`157`
`155`	`158`	`_membersByImplementsContext = new Lazy<ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>>(() =>`
`156`		`- new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(`
`157`		`- implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);`
	`159`	`+ new ConcurrentDictionary<VBAParser.ImplementsStmtContext, Declaration[]>(`
	`160`	`+ implementableMembers.ToDictionary(item => item.Context, item => item.Members)), true);`
	`161`	`+`
	`162`	`+ _nonBaseAsType = new Lazy<List<Declaration>>(() =>`
	`163`	`+ _declarations.AllValues().Where(d =>`
	`164`	`+ !string.IsNullOrWhiteSpace(d.AsTypeName)`
	`165`	`+ && !d.AsTypeIsBaseType`
	`166`	`+ && d.DeclarationType != DeclarationType.Project`
	`167`	`+ && d.DeclarationType != DeclarationType.ProceduralModule).ToList()`
	`168`	`+ ,true);`
`158`	`169`	`}`
`159`	`170`
`160`	`171`	`public Declaration FindSelectedDeclaration(ICodePane activeCodePane)`
`@@ -228,38 +239,22 @@ public IEnumerable<Declaration> Members(QualifiedModuleName module)`
`228`	`239`	`return _declarations[module];`
`229`	`240`	`}`
`230`	`241`
`231`		`- private IEnumerable<Declaration> _nonBaseAsType;`
`232`	`242`	`public IEnumerable<Declaration> FindDeclarationsWithNonBaseAsType()`
`233`	`243`	`{`
`234`		`- lock (ThreadLock)`
`235`		`- {`
`236`		`- return _nonBaseAsType ?? (_nonBaseAsType = _declarations.AllValues().Where(d =>`
`237`		`- !string.IsNullOrWhiteSpace(d.AsTypeName)`
`238`		`- && !d.AsTypeIsBaseType`
`239`		`- && d.DeclarationType != DeclarationType.Project`
`240`		`- && d.DeclarationType != DeclarationType.ProceduralModule).ToList());`
`241`		`- }`
`242`		`- }`
	`244`	`+ return _nonBaseAsType.Value;`
`243`	`245`
`244`		`- private readonly Lazy<ConcurrentBag<Declaration>> _eventHandlers;`
	`246`	`+ }`
	`247`	`+`
`245`	`248`	`public IEnumerable<Declaration> FindEventHandlers()`
`246`	`249`	`{`
`247`		`- lock (ThreadLock)`
`248`		`- {`
`249`		`- return _eventHandlers.Value;`
`250`		`- }`
	`250`	`+ return _eventHandlers.Value;`
`251`	`251`	`}`
`252`	`252`
`253`		`- private readonly Lazy<ConcurrentBag<Declaration>> _classes;`
`254`		`-`
`255`	`253`	`public IEnumerable<Declaration> Classes`
`256`	`254`	`{`
`257`	`255`	`get`
`258`	`256`	`{`
`259`		`- lock (ThreadLock)`
`260`		`- {`
`261`		`- return _classes.Value;`
`262`		`- }`
	`257`	`+ return _classes.Value;`
`263`	`258`	`}`
`264`	`259`	`}`
`265`	`260`
`@@ -269,10 +264,7 @@ public IEnumerable<Declaration> Projects`
`269`	`264`	`{`
`270`	`265`	`get`
`271`	`266`	`{`
`272`		`- lock (ThreadLock)`
`273`		`- {`
`274`		`- return _projects.Value;`
`275`		`- }`
	`267`	`+ return _projects.Value;`
`276`	`268`	`}`
`277`	`269`	`}`
`278`	`270`
`@@ -290,10 +282,7 @@ public IEnumerable<Declaration> UserDeclarations(DeclarationType type)`
`290`	`282`
`291`	`283`	`public IEnumerable<UnboundMemberDeclaration> FreshUnresolvedMemberDeclarations()`
`292`	`284`	`{`
`293`		`- lock (ThreadLock)`
`294`		`- {`
`295`		`- return _newUnresolved.ToArray();`
`296`		`- }`
	`285`	`+ return _newUnresolved.ToArray(); //This does not need a lock because enumerators over a ConcurrentBag uses a snapshot.`
`297`	`286`	`}`
`298`	`287`
`299`	`288`	`public IEnumerable<UnboundMemberDeclaration> UnresolvedMemberDeclarations()`
`@@ -338,19 +327,18 @@ public Declaration FindParameter(Declaration procedure, string parameterName)`
`338`	`327`	`public IEnumerable<Declaration> FindMemberMatches(Declaration parent, string memberName)`
`339`	`328`	`{`
`340`	`329`	`ConcurrentBag<Declaration> children;`
`341`		`- if (_declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children))`
`342`		`- {`
`343`		`- return children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)`
`344`		`- && item.IdentifierName == memberName).ToList();`
`345`		`- }`
`346`		`-`
`347`		`- return Enumerable.Empty<Declaration>();`
	`330`	`+ return _declarations.TryGetValue(parent.QualifiedName.QualifiedModuleName, out children)`
	`331`	`+ ? children.Where(item => item.DeclarationType.HasFlag(DeclarationType.Member)`
	`332`	`+ && item.IdentifierName == memberName).ToList()`
	`333`	`+ : Enumerable.Empty<Declaration>();`
`348`	`334`	`}`
`349`	`335`
`350`	`336`	`public IEnumerable<IAnnotation> FindAnnotations(QualifiedModuleName module)`
`351`	`337`	`{`
`352`	`338`	`ConcurrentBag<IAnnotation> result;`
`353`		`- return _annotations.TryGetValue(module, out result) ? result : Enumerable.Empty<IAnnotation>();`
	`339`	`+ return _annotations.TryGetValue(module, out result)`
	`340`	`+ ? result`
	`341`	`+ : Enumerable.Empty<IAnnotation>();`
`354`	`342`	`}`
`355`	`343`
`356`	`344`	`public bool IsMatch(string declarationName, string potentialMatchName)`
`@@ -405,7 +393,8 @@ public Declaration FindProject(string name, Declaration currentScope = null)`
`405`	`393`	`Declaration result = null;`
`406`	`394`	`try`
`407`	`395`	`{`
`408`		`- result = MatchName(name).SingleOrDefault(project => project.DeclarationType.HasFlag(DeclarationType.Project)`
	`396`	`+ result = MatchName(name).SingleOrDefault(project =>`
	`397`	`+ project.DeclarationType.HasFlag(DeclarationType.Project)`
`409`	`398`	`&& (currentScope == null \|\| project.ProjectId == currentScope.ProjectId));`
`410`	`399`	`}`
`411`	`400`	`catch (InvalidOperationException exception)`
`@@ -416,7 +405,7 @@ public Declaration FindProject(string name, Declaration currentScope = null)`
`416`	`405`	`return result;`
`417`	`406`	`}`
`418`	`407`
`419`		`- public Declaration FindStdModule(string name, Declaration parent = null, bool includeBuiltIn = false)`
	`408`	`+ public Declaration FindStdModule(string name, Declaration parent, bool includeBuiltIn = false)`
`420`	`409`	`{`
`421`	`410`	`Debug.Assert(parent != null);`
`422`	`411`	`Declaration result = null;`
`@@ -435,7 +424,7 @@ public Declaration FindStdModule(string name, Declaration parent = null, bool in`
`435`	`424`	`return result;`
`436`	`425`	`}`
`437`	`426`
`438`		`- public Declaration FindClassModule(string name, Declaration parent = null, bool includeBuiltIn = false)`
	`427`	`+ public Declaration FindClassModule(string name, Declaration parent, bool includeBuiltIn = false)`
`439`	`428`	`{`
`440`	`429`	`Debug.Assert(parent != null);`
`441`	`430`	`Declaration result = null;`
Original file line number	Diff line number	Diff line change
`@@ -704,6 +704,10 @@ private void ParseAllInternal(object requestor, CancellationToken token)`
`704`	`704`	`{`
`705`	`705`	`token.ThrowIfCancellationRequested();`
`706`	`706`
	`707`	`+ Thread.Sleep(50); //Simplistic hack to give the VBE time to do its work in case the parsing run is requested from an event handler.`
	`708`	`+`
	`709`	`+ token.ThrowIfCancellationRequested();`
	`710`	`+`
`707`	`711`	`State.RefreshProjects(_vbe);`
`708`	`712`
`709`	`713`	`token.ThrowIfCancellationRequested();`
Original file line number	Diff line number	Diff line change
`@@ -1072,12 +1072,13 @@ public HashSet<QualifiedModuleName> ModulesReferencedBy(QualifiedModuleName refe`
`1072`	`1072`
`1073`	`1073`	`public HashSet<QualifiedModuleName> ModulesReferencedBy(IEnumerable<QualifiedModuleName> referencingModules)`
`1074`	`1074`	`{`
`1075`		`- var referencedModules = new HashSet<QualifiedModuleName>();`
	`1075`	`+ var toModules = new HashSet<QualifiedModuleName>();`
	`1076`	`+`
`1076`	`1077`	`foreach (var referencingModule in referencingModules)`
`1077`	`1078`	`{`
`1078`		`- referencedModules.UnionWith(ModulesReferencedBy(referencingModule));`
	`1079`	`+ toModules.UnionWith(ModulesReferencedBy(referencingModule));`
`1079`	`1080`	`}`
`1080`		`- return referencedModules;`
	`1081`	`+ return toModules;`
`1081`	`1082`	`}`
`1082`	`1083`
`1083`	`1084`	`public HashSet<QualifiedModuleName> ModulesReferencing(QualifiedModuleName referencedModule)`
Original file line number	Diff line number	Diff line change
`@@ -82,5 +82,14 @@ public static class User32`
`82`	`82`
`83`	`83`	`[DllImport("user32.dll", CharSet = CharSet.Unicode)]`
`84`	`84`	`internal static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string lclassName, string windowTitle);`
	`85`	`+`
	`86`	`+ /// <summary>`
	`87`	`+ /// Validates a window handle.`
	`88`	`+ /// </summary>`
	`89`	`+ /// <param name="hWnd">The handle to validate.</param>`
	`90`	`+ /// <returns></returns>`
	`91`	`+ [DllImport("user32.dll")]`
	`92`	`+ [return: MarshalAs(UnmanagedType.Bool)]`
	`93`	`+ internal static extern bool IsWindow(IntPtr hWnd);`
`85`	`94`	`}`
`86`	`95`	`}`