Convert GetDeclarationsForReference return to List<Declaration> (#1658)

* Convert GetDeclarationsForReference return to List<Declaration> to remove yield => .ToList() paradigm.

* Small refactor in CreateParameterDeclaration to allow releasing struct.

Author: comintern

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)

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);