Merge branch 'next' of https://github.com/rubberduck-vba/Rubberduck into next

ThunderFrame · ThunderFrame · commit 81399f580c9f · 2016-06-02T12:07:26.000+10:00
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/UiDispatcher.cs b/RetailCoder.VBE/UI/Command/MenuItems/UiDispatcher.cs
@@ -8,7 +8,7 @@ public static class UiDispatcher
         // thanks to Pellared on http://stackoverflow.com/a/12909070/1188513
 
         private static SynchronizationContext UiContext { get; set; }
-
+        
         public static void Initialize()
         {
             if (UiContext == null)
diff --git a/RetailCoder.VBE/UI/UnitTesting/TestExplorerModel.cs b/RetailCoder.VBE/UI/UnitTesting/TestExplorerModel.cs
@@ -2,6 +2,7 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Windows.Media;
+using System.Windows.Threading;
 using Microsoft.Vbe.Interop;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.UI.Command.MenuItems;
@@ -13,12 +14,15 @@ public class TestExplorerModel : ViewModelBase
     {
         private readonly VBE _vbe;
         private readonly RubberduckParserState _state;
+        private readonly Dispatcher _dispatcher;
 
         public TestExplorerModel(VBE vbe, RubberduckParserState state)
         {
             _vbe = vbe;
             _state = state;
             _state.StateChanged += State_StateChanged;
+
+            _dispatcher = Dispatcher.CurrentDispatcher;
         }
 
         private void State_StateChanged(object sender, ParserStateEventArgs e)
@@ -33,34 +37,38 @@ private void State_StateChanged(object sender, ParserStateEventArgs e)
                                  t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
                                  t.Declaration.ProjectId == test.Declaration.ProjectId)).ToList();
 
-            // remove old tests
-            foreach (var test in removedTests)
+            _dispatcher.Invoke(() =>
             {
-                UiDispatcher.Invoke(() => { Tests.Remove(test); });
-            }
 
-            // update declarations for existing tests--declarations are immutable
-            foreach (var test in Tests.Except(removedTests))
-            {
-                var declaration = tests.First(t =>
-                    t.Declaration.ComponentName == test.Declaration.ComponentName &&
-                    t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
-                    t.Declaration.ProjectId == test.Declaration.ProjectId).Declaration;
+                // remove old tests
+                foreach (var test in removedTests)
+                {
+                    Tests.Remove(test);
+                }
 
-                test.SetDeclaration(declaration);
-            }
+                // update declarations for existing tests--declarations are immutable
+                foreach (var test in Tests.Except(removedTests))
+                {
+                    var declaration = tests.First(t =>
+                        t.Declaration.ComponentName == test.Declaration.ComponentName &&
+                        t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
+                        t.Declaration.ProjectId == test.Declaration.ProjectId).Declaration;
 
-            // add new tests
-            foreach (var test in tests)
-            {
-                if (!Tests.Any(t =>
-                    t.Declaration.ComponentName == test.Declaration.ComponentName &&
-                    t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
-                    t.Declaration.ProjectId == test.Declaration.ProjectId))
+                    test.SetDeclaration(declaration);
+                }
+
+                // add new tests
+                foreach (var test in tests)
                 {
-                    UiDispatcher.Invoke(() => { Tests.Add(test); });
+                    if (!Tests.Any(t =>
+                        t.Declaration.ComponentName == test.Declaration.ComponentName &&
+                        t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
+                        t.Declaration.ProjectId == test.Declaration.ProjectId))
+                    {
+                        Tests.Add(test);
+                    }
                 }
-            }
+            });
         }
 
         private readonly ObservableCollection<TestMethod> _tests = new ObservableCollection<TestMethod>();
diff --git a/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs b/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs
@@ -1,6 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
 using Microsoft.Vbe.Interop;
@@ -19,7 +18,6 @@
 using TYPEFLAGS = System.Runtime.InteropServices.ComTypes.TYPEFLAGS;
 using VARDESC = System.Runtime.InteropServices.ComTypes.VARDESC;
 using Rubberduck.Parsing.Annotations;
-using System.Linq;
 using Rubberduck.Parsing.Grammar;
 
 namespace Rubberduck.Parsing.Symbols
@@ -130,21 +128,22 @@ private string GetTypeName(ITypeInfo info)
             return typeName;
         }
 
-        public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)
+        public List<Declaration> GetDeclarationsForReference(Reference reference)
         {
+            var output = new List<Declaration>();
             var projectName = reference.Name;
             var path = reference.FullPath;
             ITypeLib typeLibrary;
             // Failure to load might mean that it's a "normal" VBProject that will get parsed by us anyway.
             LoadTypeLibEx(path, REGKIND.REGKIND_NONE, out typeLibrary);
             if (typeLibrary == null)
             {
-                yield break;
+                return output;
             }
             var projectQualifiedModuleName = new QualifiedModuleName(projectName, path, projectName);
             var projectQualifiedMemberName = new QualifiedMemberName(projectQualifiedModuleName, projectName);
             var projectDeclaration = new ProjectDeclaration(projectQualifiedMemberName, projectName, isBuiltIn: true);
-            yield return projectDeclaration;
+            output.Add(projectDeclaration);
 
             var typeCount = typeLibrary.GetTypeInfoCount();
             for (var i = 0; i < typeCount; i++)
@@ -156,7 +155,7 @@ public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)
                 }
                 catch (NullReferenceException)
                 {
-                    yield break;
+                    return output;
                 }
 
                 if (info == null)
@@ -241,53 +240,56 @@ public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)
                             attributes);
                         break;
                 }
+                info.ReleaseTypeAttr(typeAttributesPointer);
 
-                yield return moduleDeclaration;
+                output.Add(moduleDeclaration);
 
                 for (var memberIndex = 0; memberIndex < typeAttributes.cFuncs; memberIndex++)
                 {
-                    FUNCDESC memberDescriptor;
                     string[] memberNames;
-                    var memberDeclaration = CreateMemberDeclaration(out memberDescriptor, typeAttributes.typekind, info, memberIndex, typeQualifiedModuleName, moduleDeclaration, out memberNames);
+
+                    IntPtr memberDescriptorPointer;
+                    info.GetFuncDesc(memberIndex, out memberDescriptorPointer);
+                    var memberDescriptor = (FUNCDESC)Marshal.PtrToStructure(memberDescriptorPointer, typeof(FUNCDESC));
+                    var memberDeclaration = CreateMemberDeclaration(memberDescriptor, typeAttributes.typekind, info, memberIndex, typeQualifiedModuleName, moduleDeclaration, out memberNames);
                     if (memberDeclaration == null)
                     {
+                        info.ReleaseFuncDesc(memberDescriptorPointer);
                         continue;
                     }
                     if (moduleDeclaration.DeclarationType == DeclarationType.ClassModule && memberDeclaration is ICanBeDefaultMember && ((ICanBeDefaultMember)memberDeclaration).IsDefaultMember)
                     {
                         ((ClassModuleDeclaration)moduleDeclaration).DefaultMember = memberDeclaration;
                     }
-                    yield return memberDeclaration;
+                    output.Add(memberDeclaration);
 
                     var parameterCount = memberDescriptor.cParams - 1;
                     for (var paramIndex = 0; paramIndex < parameterCount; paramIndex++)
                     {
                         var parameter = CreateParameterDeclaration(memberNames, paramIndex, memberDescriptor, typeQualifiedModuleName, memberDeclaration, info);
-                        if (memberDeclaration is IDeclarationWithParameter)
+                        var declaration = memberDeclaration as IDeclarationWithParameter;
+                        if (declaration != null)
                         {
-                            ((IDeclarationWithParameter)memberDeclaration).AddParameter(parameter);
+                            declaration.AddParameter(parameter);
                         }
-                        yield return parameter;
+                        output.Add(parameter);
                     }
+                    info.ReleaseFuncDesc(memberDescriptorPointer);
                 }
 
                 for (var fieldIndex = 0; fieldIndex < typeAttributes.cVars; fieldIndex++)
                 {
-                    yield return CreateFieldDeclaration(info, fieldIndex, typeDeclarationType, typeQualifiedModuleName, moduleDeclaration);
+                    output.Add(CreateFieldDeclaration(info, fieldIndex, typeDeclarationType, typeQualifiedModuleName, moduleDeclaration));
                 }
             }
+            return output;
         }
 
-        private Declaration CreateMemberDeclaration(out FUNCDESC memberDescriptor, TYPEKIND typeKind, ITypeInfo info, int memberIndex,
+        private Declaration CreateMemberDeclaration(FUNCDESC memberDescriptor, TYPEKIND typeKind, ITypeInfo info, int memberIndex,
             QualifiedModuleName typeQualifiedModuleName, Declaration moduleDeclaration, out string[] memberNames)
         {
-            IntPtr memberDescriptorPointer;
-            info.GetFuncDesc(memberIndex, out memberDescriptorPointer);
-            memberDescriptor = (FUNCDESC)Marshal.PtrToStructure(memberDescriptorPointer, typeof(FUNCDESC));
-
             if (memberDescriptor.callconv != CALLCONV.CC_STDCALL)
             {
-                memberDescriptor = new FUNCDESC();
                 memberNames = new string[] { };
                 return null;
             }
@@ -425,7 +427,8 @@ private Declaration CreateFieldDeclaration(ITypeInfo info, int fieldIndex, Decla
             var fieldName = names[0];
             var memberType = GetDeclarationType(varDesc, typeDeclarationType);
 
-            var asTypeName = GetTypeName(varDesc.elemdescVar.tdesc, info);            
+            var asTypeName = GetTypeName(varDesc.elemdescVar.tdesc, info);
+            info.ReleaseVarDesc(ppVarDesc);
 
             return new Declaration(new QualifiedMemberName(typeQualifiedModuleName, fieldName),
                 moduleDeclaration, moduleDeclaration, asTypeName, null, false, false, Accessibility.Global, memberType, null,
@@ -458,6 +461,7 @@ private ParameterDeclaration CreateParameterDeclaration(IReadOnlyList<string> me
 
         private IEnumerable<string> GetImplementedInterfaceNames(TYPEATTR typeAttr, ITypeInfo info)
         {
+            var output = new List<string>();
             for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)
             {
                 int href;
@@ -470,10 +474,11 @@ private IEnumerable<string> GetImplementedInterfaceNames(TYPEATTR typeAttr, ITyp
                 if (implTypeName != "IDispatch" && implTypeName != "IUnknown")
                 {
                     // skip IDispatch.. just about everything implements it and RD doesn't need to care about it; don't care about IUnknown either
-                    yield return implTypeName;
+                    output.Add(implTypeName);
                 }
                 //Debug.WriteLine(string.Format("\tImplements {0}", implTypeName));
             }
+            return output;
         }
 
         private DeclarationType GetDeclarationType(ITypeLib typeLibrary, int i)
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -348,7 +348,7 @@ private void SyncComReferences(IReadOnlyList<VBProject> projects)
                     if (!map.IsLoaded)
                     {
                         _state.OnStatusMessageUpdate(ParserState.LoadingReference.ToString());
-                        var items = _comReflector.GetDeclarationsForReference(reference).ToList();
+                        var items = _comReflector.GetDeclarationsForReference(reference);
                         foreach (var declaration in items)
                         {
                             _state.AddDeclaration(declaration);
diff --git a/Rubberduck.VBEEditor/QualifiedModuleName.cs b/Rubberduck.VBEEditor/QualifiedModuleName.cs
@@ -30,12 +30,15 @@ private static string GetDisplayName(VBProject project)
                 //Eg. A Workbook's parent is the application, so read the workbook's name
                 try
                 {
-                    var nameProperty = project.VBComponents.Cast<VBComponent>()
+                    var component = project.VBComponents.Cast<VBComponent>()
                         .FirstOrDefault(comp => comp.Type == vbext_ComponentType.vbext_ct_Document
                                                 && comp.Properties.Item("Name").Value != null
                                                 && comp.Properties.Item("Parent")
-                                                .Object.Equals(comp.Properties.Item("Application").Object))
-                                                .Properties.Cast<Property>().FirstOrDefault(property => property.Name == "Name");
+                                                    .Object.Equals(comp.Properties.Item("Application").Object));
+
+                    if (component == null) { return null; }
+
+                    var nameProperty = component.Properties.Cast<Property>().FirstOrDefault(property => property.Name == "Name");
                     return nameProperty == null
                         ? null
                         : nameProperty.Value.ToString();
diff --git a/RubberduckTests/Mocks/MockProjectBuilder.cs b/RubberduckTests/Mocks/MockProjectBuilder.cs
@@ -21,7 +21,6 @@ public class MockProjectBuilder
         private readonly Mock<References> _vbReferences;
 
         private readonly List<Mock<VBComponent>> _componentsMock = new List<Mock<VBComponent>>();
-        //private readonly List<VBComponent> _components = new List<VBComponent>();
         private readonly List<Reference> _references = new List<Reference>();
 
         public Mock<VBComponents> MockVBComponents
@@ -39,6 +38,11 @@ private List<VBComponent> Components
             get { return _componentsMock.Select(m => m.Object).ToList(); }
         }
 
+        public void RemoveComponent(Mock<VBComponent> component)
+        {
+            _componentsMock.Remove(component);
+        }
+
         public MockProjectBuilder(string name, string filename, vbext_ProjectProtection protection, Func<VBE> getVbe, MockVbeBuilder mockVbeBuilder)
         {
             _getVbe = getVbe;
diff --git a/RubberduckTests/RubberduckTests.csproj b/RubberduckTests/RubberduckTests.csproj
@@ -172,6 +172,7 @@
     <Compile Include="UnitTesting\AssertTests.cs" />
     <Compile Include="UnitTesting\EngineTests.cs" />
     <Compile Include="UnitTesting\DiscoveryTests.cs" />
+    <Compile Include="UnitTesting\ViewModelTests.cs" />
     <Compile Include="VbeTestBase.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/RubberduckTests/UnitTesting/DiscoveryTests.cs b/RubberduckTests/UnitTesting/DiscoveryTests.cs
@@ -1,8 +1,11 @@
 ﻿using System.Linq;
+using System.Threading;
 using Microsoft.Vbe.Interop;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
 using Rubberduck.Parsing.VBA;
+using Rubberduck.UI.Command.MenuItems;
+using Rubberduck.UI.UnitTesting;
 using Rubberduck.UnitTesting;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.VBEHost;
diff --git a/RubberduckTests/UnitTesting/ViewModelTests.cs b/RubberduckTests/UnitTesting/ViewModelTests.cs

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public static class UiDispatcher`
`8`	`8`	`// thanks to Pellared on http://stackoverflow.com/a/12909070/1188513`
`9`	`9`
`10`	`10`	`private static SynchronizationContext UiContext { get; set; }`
`11`		`-`
	`11`	`+`
`12`	`12`	`public static void Initialize()`
`13`	`13`	`{`
`14`	`14`	`if (UiContext == null)`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`		`-using System.Diagnostics;`
`4`	`3`	`using System.Runtime.InteropServices;`
`5`	`4`	`using System.Runtime.InteropServices.ComTypes;`
`6`	`5`	`using Microsoft.Vbe.Interop;`
`@@ -19,7 +18,6 @@`
`19`	`18`	`using TYPEFLAGS = System.Runtime.InteropServices.ComTypes.TYPEFLAGS;`
`20`	`19`	`using VARDESC = System.Runtime.InteropServices.ComTypes.VARDESC;`
`21`	`20`	`using Rubberduck.Parsing.Annotations;`
`22`		`-using System.Linq;`
`23`	`21`	`using Rubberduck.Parsing.Grammar;`
`24`	`22`
`25`	`23`	`namespace Rubberduck.Parsing.Symbols`
`@@ -130,21 +128,22 @@ private string GetTypeName(ITypeInfo info)`
`130`	`128`	`return typeName;`
`131`	`129`	`}`
`132`	`130`
`133`		`- public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)`
	`131`	`+ public List<Declaration> GetDeclarationsForReference(Reference reference)`
`134`	`132`	`{`
	`133`	`+ var output = new List<Declaration>();`
`135`	`134`	`var projectName = reference.Name;`
`136`	`135`	`var path = reference.FullPath;`
`137`	`136`	`ITypeLib typeLibrary;`
`138`	`137`	`// Failure to load might mean that it's a "normal" VBProject that will get parsed by us anyway.`
`139`	`138`	`LoadTypeLibEx(path, REGKIND.REGKIND_NONE, out typeLibrary);`
`140`	`139`	`if (typeLibrary == null)`
`141`	`140`	`{`
`142`		`- yield break;`
	`141`	`+ return output;`
`143`	`142`	`}`
`144`	`143`	`var projectQualifiedModuleName = new QualifiedModuleName(projectName, path, projectName);`
`145`	`144`	`var projectQualifiedMemberName = new QualifiedMemberName(projectQualifiedModuleName, projectName);`
`146`	`145`	`var projectDeclaration = new ProjectDeclaration(projectQualifiedMemberName, projectName, isBuiltIn: true);`
`147`		`- yield return projectDeclaration;`
	`146`	`+ output.Add(projectDeclaration);`
`148`	`147`
`149`	`148`	`var typeCount = typeLibrary.GetTypeInfoCount();`
`150`	`149`	`for (var i = 0; i < typeCount; i++)`
`@@ -156,7 +155,7 @@ public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)`
`156`	`155`	`}`
`157`	`156`	`catch (NullReferenceException)`
`158`	`157`	`{`
`159`		`- yield break;`
	`158`	`+ return output;`
`160`	`159`	`}`
`161`	`160`
`162`	`161`	`if (info == null)`
`@@ -241,53 +240,56 @@ public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)`
`241`	`240`	`attributes);`
`242`	`241`	`break;`
`243`	`242`	`}`
	`243`	`+ info.ReleaseTypeAttr(typeAttributesPointer);`
`244`	`244`
`245`		`- yield return moduleDeclaration;`
	`245`	`+ output.Add(moduleDeclaration);`
`246`	`246`
`247`	`247`	`for (var memberIndex = 0; memberIndex < typeAttributes.cFuncs; memberIndex++)`
`248`	`248`	`{`
`249`		`- FUNCDESC memberDescriptor;`
`250`	`249`	`string[] memberNames;`
`251`		`- var memberDeclaration = CreateMemberDeclaration(out memberDescriptor, typeAttributes.typekind, info, memberIndex, typeQualifiedModuleName, moduleDeclaration, out memberNames);`
	`250`	`+`
	`251`	`+ IntPtr memberDescriptorPointer;`
	`252`	`+ info.GetFuncDesc(memberIndex, out memberDescriptorPointer);`
	`253`	`+ var memberDescriptor = (FUNCDESC)Marshal.PtrToStructure(memberDescriptorPointer, typeof(FUNCDESC));`
	`254`	`+ var memberDeclaration = CreateMemberDeclaration(memberDescriptor, typeAttributes.typekind, info, memberIndex, typeQualifiedModuleName, moduleDeclaration, out memberNames);`
`252`	`255`	`if (memberDeclaration == null)`
`253`	`256`	`{`
	`257`	`+ info.ReleaseFuncDesc(memberDescriptorPointer);`
`254`	`258`	`continue;`
`255`	`259`	`}`
`256`	`260`	`if (moduleDeclaration.DeclarationType == DeclarationType.ClassModule && memberDeclaration is ICanBeDefaultMember && ((ICanBeDefaultMember)memberDeclaration).IsDefaultMember)`
`257`	`261`	`{`
`258`	`262`	`((ClassModuleDeclaration)moduleDeclaration).DefaultMember = memberDeclaration;`
`259`	`263`	`}`
`260`		`- yield return memberDeclaration;`
	`264`	`+ output.Add(memberDeclaration);`
`261`	`265`
`262`	`266`	`var parameterCount = memberDescriptor.cParams - 1;`
`263`	`267`	`for (var paramIndex = 0; paramIndex < parameterCount; paramIndex++)`
`264`	`268`	`{`
`265`	`269`	`var parameter = CreateParameterDeclaration(memberNames, paramIndex, memberDescriptor, typeQualifiedModuleName, memberDeclaration, info);`
`266`		`- if (memberDeclaration is IDeclarationWithParameter)`
	`270`	`+ var declaration = memberDeclaration as IDeclarationWithParameter;`
	`271`	`+ if (declaration != null)`
`267`	`272`	`{`
`268`		`- ((IDeclarationWithParameter)memberDeclaration).AddParameter(parameter);`
	`273`	`+ declaration.AddParameter(parameter);`
`269`	`274`	`}`
`270`		`- yield return parameter;`
	`275`	`+ output.Add(parameter);`
`271`	`276`	`}`
	`277`	`+ info.ReleaseFuncDesc(memberDescriptorPointer);`
`272`	`278`	`}`
`273`	`279`
`274`	`280`	`for (var fieldIndex = 0; fieldIndex < typeAttributes.cVars; fieldIndex++)`
`275`	`281`	`{`
`276`		`- yield return CreateFieldDeclaration(info, fieldIndex, typeDeclarationType, typeQualifiedModuleName, moduleDeclaration);`
	`282`	`+ output.Add(CreateFieldDeclaration(info, fieldIndex, typeDeclarationType, typeQualifiedModuleName, moduleDeclaration));`
`277`	`283`	`}`
`278`	`284`	`}`
	`285`	`+ return output;`
`279`	`286`	`}`
`280`	`287`
`281`		`- private Declaration CreateMemberDeclaration(out FUNCDESC memberDescriptor, TYPEKIND typeKind, ITypeInfo info, int memberIndex,`
	`288`	`+ private Declaration CreateMemberDeclaration(FUNCDESC memberDescriptor, TYPEKIND typeKind, ITypeInfo info, int memberIndex,`
`282`	`289`	`QualifiedModuleName typeQualifiedModuleName, Declaration moduleDeclaration, out string[] memberNames)`
`283`	`290`	`{`
`284`		`- IntPtr memberDescriptorPointer;`
`285`		`- info.GetFuncDesc(memberIndex, out memberDescriptorPointer);`
`286`		`- memberDescriptor = (FUNCDESC)Marshal.PtrToStructure(memberDescriptorPointer, typeof(FUNCDESC));`
`287`		`-`
`288`	`291`	`if (memberDescriptor.callconv != CALLCONV.CC_STDCALL)`
`289`	`292`	`{`
`290`		`- memberDescriptor = new FUNCDESC();`
`291`	`293`	`memberNames = new string[] { };`
`292`	`294`	`return null;`
`293`	`295`	`}`
`@@ -425,7 +427,8 @@ private Declaration CreateFieldDeclaration(ITypeInfo info, int fieldIndex, Decla`
`425`	`427`	`var fieldName = names[0];`
`426`	`428`	`var memberType = GetDeclarationType(varDesc, typeDeclarationType);`
`427`	`429`
`428`		`- var asTypeName = GetTypeName(varDesc.elemdescVar.tdesc, info);`
	`430`	`+ var asTypeName = GetTypeName(varDesc.elemdescVar.tdesc, info);`
	`431`	`+ info.ReleaseVarDesc(ppVarDesc);`
`429`	`432`
`430`	`433`	`return new Declaration(new QualifiedMemberName(typeQualifiedModuleName, fieldName),`
`431`	`434`	`moduleDeclaration, moduleDeclaration, asTypeName, null, false, false, Accessibility.Global, memberType, null,`
`@@ -458,6 +461,7 @@ private ParameterDeclaration CreateParameterDeclaration(IReadOnlyList<string> me`
`458`	`461`
`459`	`462`	`private IEnumerable<string> GetImplementedInterfaceNames(TYPEATTR typeAttr, ITypeInfo info)`
`460`	`463`	`{`
	`464`	`+ var output = new List<string>();`
`461`	`465`	`for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)`
`462`	`466`	`{`
`463`	`467`	`int href;`
`@@ -470,10 +474,11 @@ private IEnumerable<string> GetImplementedInterfaceNames(TYPEATTR typeAttr, ITyp`
`470`	`474`	`if (implTypeName != "IDispatch" && implTypeName != "IUnknown")`
`471`	`475`	`{`
`472`	`476`	`// skip IDispatch.. just about everything implements it and RD doesn't need to care about it; don't care about IUnknown either`
`473`		`- yield return implTypeName;`
	`477`	`+ output.Add(implTypeName);`
`474`	`478`	`}`
`475`	`479`	`//Debug.WriteLine(string.Format("\tImplements {0}", implTypeName));`
`476`	`480`	`}`
	`481`	`+ return output;`
`477`	`482`	`}`
`478`	`483`
`479`	`484`	`private DeclarationType GetDeclarationType(ITypeLib typeLibrary, int i)`
Original file line number	Diff line number	Diff line change
`@@ -348,7 +348,7 @@ private void SyncComReferences(IReadOnlyList<VBProject> projects)`
`348`	`348`	`if (!map.IsLoaded)`
`349`	`349`	`{`
`350`	`350`	`_state.OnStatusMessageUpdate(ParserState.LoadingReference.ToString());`
`351`		`- var items = _comReflector.GetDeclarationsForReference(reference).ToList();`
	`351`	`+ var items = _comReflector.GetDeclarationsForReference(reference);`
`352`	`352`	`foreach (var declaration in items)`
`353`	`353`	`{`
`354`	`354`	`_state.AddDeclaration(declaration);`