applying default member attributes to, well, default members. not always what one might expect though.

Author: retailcoder

RetailCoder.VBE/UI/Controls/SearchResultPresenterInstanceManager.cs

@@ -42,8 +42,14 @@ private void viewModel_LastTabClosed(object sender, EventArgs e)
 
         public void Dispose()
         {
-            _view.ViewModel.LastTabClosed -= viewModel_LastTabClosed;
-            _presenter.Dispose();
+            if (_view.ViewModel != null)
+            {
+                _view.ViewModel.LastTabClosed -= viewModel_LastTabClosed;
+            }
+            if (_presenter != null)
+            {
+                _presenter.Dispose();
+            }
         }
     }
 }

Rubberduck.Parsing/Rubberduck.Parsing.csproj

@@ -179,6 +179,7 @@
     <Compile Include="Symbols\IdentifierReferenceListener.cs" />
     <Compile Include="Symbols\ValuedDeclaration.cs" />
     <Compile Include="VBA\AttributeParser.cs" />
+    <Compile Include="VBA\Attributes.cs" />
     <Compile Include="VBA\AttributesBaseListener.cs" />
     <Compile Include="VBA\AttributesBaseVisitor.cs" />
     <Compile Include="VBA\AttributesLexer.cs" />

Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs

@@ -1,9 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
 using Microsoft.Vbe.Interop;
+using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
+using CALLCONV = System.Runtime.InteropServices.ComTypes.CALLCONV;
 using FUNCFLAGS = System.Runtime.InteropServices.ComTypes.FUNCFLAGS;
 using TYPEDESC = System.Runtime.InteropServices.ComTypes.TYPEDESC;
 using TYPEKIND = System.Runtime.InteropServices.ComTypes.TYPEKIND;
@@ -111,8 +114,7 @@ public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)
 
                 QualifiedModuleName typeQualifiedModuleName;
                 QualifiedMemberName typeQualifiedMemberName;
-                if (typeDeclarationType == DeclarationType.Enumeration ||
-                    typeDeclarationType == DeclarationType.UserDefinedType)
+                if (typeDeclarationType == DeclarationType.Enumeration || typeDeclarationType == DeclarationType.UserDefinedType)
                 {
                     typeQualifiedModuleName = projectQualifiedModuleName;
                     typeQualifiedMemberName = new QualifiedMemberName(projectQualifiedModuleName, typeName);
@@ -131,94 +133,144 @@ public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)
 
                 var typeAttributes = (TYPEATTR)Marshal.PtrToStructure(typeAttributesPointer, typeof (TYPEATTR));
                 //var implements = GetImplementedInterfaceNames(typeAttributes, info);
-
+                
                 for (var memberIndex = 0; memberIndex < typeAttributes.cFuncs; memberIndex++)
                 {
-                    IntPtr memberDescriptorPointer;
-                    info.GetFuncDesc(memberIndex, out memberDescriptorPointer);
-                    var memberDescriptor = (FUNCDESC) Marshal.PtrToStructure(memberDescriptorPointer, typeof (FUNCDESC));
-                            
-                    var memberNames = new string[255]; // member name at index 0; array contains parameter names too
-                    int namesArrayLength;
-                    info.GetNames(memberDescriptor.memid, memberNames, 255, out namesArrayLength);
-
-                    var memberName = memberNames[0];
-
-                    var funcValueType = (VarEnum)memberDescriptor.elemdescFunc.tdesc.vt;
-                    var memberDeclarationType = GetDeclarationType(memberDescriptor, funcValueType);
-
-                    var asTypeName = string.Empty;
-                    if (memberDeclarationType != DeclarationType.Procedure && !TypeNames.TryGetValue(funcValueType, out asTypeName))
+                    FUNCDESC memberDescriptor;
+                    string[] memberNames;
+                    var memberDeclaration = CreateMemberDeclaration(out memberDescriptor, typeAttributes.typekind, info, memberIndex, typeQualifiedModuleName, moduleDeclaration, out memberNames);
+                    if (memberDeclaration == null)
                     {
-                        asTypeName = funcValueType.ToString(); //TypeNames[VarEnum.VT_VARIANT];
+                        continue;
                     }
 
-                    var memberDeclaration = new Declaration(new QualifiedMemberName(typeQualifiedModuleName, memberName), moduleDeclaration, moduleDeclaration, asTypeName, false, false, Accessibility.Global, memberDeclarationType, null, Selection.Home);
                     yield return memberDeclaration;
 
                     var parameterCount = memberDescriptor.cParams - 1;
                     for (var paramIndex = 0; paramIndex < parameterCount; paramIndex++)
                     {
-                        var paramName = memberNames[paramIndex + 1];
-
-                        var paramPointer = new IntPtr(memberDescriptor.lprgelemdescParam.ToInt64() + Marshal.SizeOf(typeof (ELEMDESC))*paramIndex);
-                        var elementDesc = (ELEMDESC) Marshal.PtrToStructure(paramPointer, typeof (ELEMDESC));
-                        var isOptional = elementDesc.desc.paramdesc.wParamFlags.HasFlag(PARAMFLAG.PARAMFLAG_FOPT);
-                        var asParamTypeName = string.Empty;
-                        
-                        var isByRef = false;
-                        var isArray = false;
-                        var paramDesc = elementDesc.tdesc;
-                        var valueType = (VarEnum) paramDesc.vt;
-                        if (valueType == VarEnum.VT_PTR || valueType == VarEnum.VT_BYREF)
-                        {
-                            //var paramTypeDesc = (TYPEDESC) Marshal.PtrToStructure(paramDesc.lpValue, typeof (TYPEDESC));
-                            isByRef = true;
-                            var paramValueType = (VarEnum) paramDesc.vt;
-                            if (!TypeNames.TryGetValue(paramValueType, out asParamTypeName))
-                            {
-                                asParamTypeName = TypeNames[VarEnum.VT_VARIANT];
-                            }
-                            //var href = paramDesc.lpValue.ToInt32();
-                            //ITypeInfo refTypeInfo;
-                            //info.GetRefTypeInfo(href, out refTypeInfo);
-
-                            // todo: get type info?
-                        }
-                        if (valueType == VarEnum.VT_CARRAY || valueType == VarEnum.VT_ARRAY || valueType == VarEnum.VT_SAFEARRAY)
-                        {
-                            // todo: tell ParamArray arrays from normal arrays
-                            isArray = true;
-                        }
-
-                        yield return new ParameterDeclaration(new QualifiedMemberName(typeQualifiedModuleName, paramName), memberDeclaration, asParamTypeName, isOptional, isByRef, isArray);
+                        yield return CreateParameterDeclaration(memberNames, paramIndex, memberDescriptor, typeQualifiedModuleName, memberDeclaration);
                     }
                 }
 
                 for (var fieldIndex = 0; fieldIndex < typeAttributes.cVars; fieldIndex++)
                 {
-                    IntPtr ppVarDesc;
-                    info.GetVarDesc(fieldIndex, out ppVarDesc);
+                    yield return CreateFieldDeclaration(info, fieldIndex, typeDeclarationType, typeQualifiedModuleName, moduleDeclaration);
+                }
+            }           
+        }
 
-                    var varDesc = (VARDESC) Marshal.PtrToStructure(ppVarDesc, typeof (VARDESC));
+        private Declaration CreateMemberDeclaration(out 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));
 
-                    var names = new string[255];
-                    int namesArrayLength;
-                    info.GetNames(varDesc.memid, names, 255, out namesArrayLength);
+            if (memberDescriptor.callconv != CALLCONV.CC_STDCALL)
+            {
+                memberDescriptor = new FUNCDESC();
+                memberNames = new string[] {};
+                return null;
+            }
 
-                    var fieldName = names[0];
-                    var fieldValueType = (VarEnum)varDesc.elemdescVar.tdesc.vt;
-                    var memberType = GetDeclarationType(varDesc, typeDeclarationType);
+            memberNames = new string[255];
+            int namesArrayLength;
+            info.GetNames(memberDescriptor.memid, memberNames, 255, out namesArrayLength);
+            
+            var memberName = memberNames[0];
+            var funcValueType = (VarEnum) memberDescriptor.elemdescFunc.tdesc.vt;
+            var memberDeclarationType = GetDeclarationType(memberDescriptor, funcValueType, typeKind);
 
-                    string asTypeName;
-                    if (!TypeNames.TryGetValue(fieldValueType, out asTypeName))
-                    {
-                        asTypeName = TypeNames[VarEnum.VT_VARIANT];
-                    }
+            var asTypeName = string.Empty;
+            if (memberDeclarationType != DeclarationType.Procedure && !TypeNames.TryGetValue(funcValueType, out asTypeName))
+            {
+                asTypeName = funcValueType.ToString(); //TypeNames[VarEnum.VT_VARIANT];
+            }
+
+            var attributes = new Attributes();
+            if (memberName == "_NewEnum" && ((FUNCFLAGS)memberDescriptor.wFuncFlags).HasFlag(FUNCFLAGS.FUNCFLAG_FNONBROWSABLE))
+            {
+                attributes.AddEnumeratorMemberAttribute(memberName);
+            }
+            else if (memberDescriptor.memid == 0)
+            {
+                attributes.AddDefaultMemberAttribute(memberName);
+                Debug.WriteLine("Default member found: {0}.{1} ({2} / {3})", moduleDeclaration.IdentifierName, memberName, memberDeclarationType, (VarEnum)memberDescriptor.elemdescFunc.tdesc.vt);
+            }
+            else if (((FUNCFLAGS)memberDescriptor.wFuncFlags).HasFlag(FUNCFLAGS.FUNCFLAG_FHIDDEN))
+            {
+                attributes.AddHiddenMemberAttribute(memberName);
+            }
 
-                    yield return new Declaration(new QualifiedMemberName(typeQualifiedModuleName, fieldName), moduleDeclaration, moduleDeclaration, asTypeName, false, false, Accessibility.Global, memberType, null, Selection.Home);
+            return new Declaration(new QualifiedMemberName(typeQualifiedModuleName, memberName),
+                moduleDeclaration, moduleDeclaration, asTypeName, false, false, Accessibility.Global, memberDeclarationType,
+                null, Selection.Home, true, null, attributes);
+        }
+
+        private Declaration CreateFieldDeclaration(ITypeInfo info, int fieldIndex, DeclarationType typeDeclarationType,
+            QualifiedModuleName typeQualifiedModuleName, Declaration moduleDeclaration)
+        {
+            IntPtr ppVarDesc;
+            info.GetVarDesc(fieldIndex, out ppVarDesc);
+
+            var varDesc = (VARDESC) Marshal.PtrToStructure(ppVarDesc, typeof (VARDESC));
+
+            var names = new string[255];
+            int namesArrayLength;
+            info.GetNames(varDesc.memid, names, 255, out namesArrayLength);
+
+            var fieldName = names[0];
+            var fieldValueType = (VarEnum) varDesc.elemdescVar.tdesc.vt;
+            var memberType = GetDeclarationType(varDesc, typeDeclarationType);
+
+            string asTypeName;
+            if (!TypeNames.TryGetValue(fieldValueType, out asTypeName))
+            {
+                asTypeName = TypeNames[VarEnum.VT_VARIANT];
+            }
+
+            return new Declaration(new QualifiedMemberName(typeQualifiedModuleName, fieldName),
+                moduleDeclaration, moduleDeclaration, asTypeName, false, false, Accessibility.Global, memberType, null,
+                Selection.Home);
+        }
+
+        private static ParameterDeclaration CreateParameterDeclaration(IReadOnlyList<string> memberNames, int paramIndex,
+            FUNCDESC memberDescriptor, QualifiedModuleName typeQualifiedModuleName, Declaration memberDeclaration)
+        {
+            var paramName = memberNames[paramIndex + 1];
+
+            var paramPointer = new IntPtr(memberDescriptor.lprgelemdescParam.ToInt64() + Marshal.SizeOf(typeof (ELEMDESC))*paramIndex);
+            var elementDesc = (ELEMDESC) Marshal.PtrToStructure(paramPointer, typeof (ELEMDESC));
+            var isOptional = elementDesc.desc.paramdesc.wParamFlags.HasFlag(PARAMFLAG.PARAMFLAG_FOPT);
+            var asParamTypeName = string.Empty;
+
+            var isByRef = false;
+            var isArray = false;
+            var paramDesc = elementDesc.tdesc;
+            var valueType = (VarEnum) paramDesc.vt;
+            if (valueType == VarEnum.VT_PTR || valueType == VarEnum.VT_BYREF)
+            {
+                //var paramTypeDesc = (TYPEDESC) Marshal.PtrToStructure(paramDesc.lpValue, typeof (TYPEDESC));
+                isByRef = true;
+                var paramValueType = (VarEnum) paramDesc.vt;
+                if (!TypeNames.TryGetValue(paramValueType, out asParamTypeName))
+                {
+                    asParamTypeName = TypeNames[VarEnum.VT_VARIANT];
                 }
-            }           
+                //var href = paramDesc.lpValue.ToInt32();
+                //ITypeInfo refTypeInfo;
+                //info.GetRefTypeInfo(href, out refTypeInfo);
+
+                // todo: get type info?
+            }
+            if (valueType == VarEnum.VT_CARRAY || valueType == VarEnum.VT_ARRAY || valueType == VarEnum.VT_SAFEARRAY)
+            {
+                // todo: tell ParamArray arrays from normal arrays
+                isArray = true;
+            }
+
+            return new ParameterDeclaration(new QualifiedMemberName(typeQualifiedModuleName, paramName), memberDeclaration, asParamTypeName, isOptional, isByRef, isArray);
         }
 
         //private IEnumerable<string> GetImplementedInterfaceNames(TYPEATTR typeAttr, ITypeInfo info)
@@ -264,7 +316,7 @@ private DeclarationType GetDeclarationType(ITypeLib typeLibrary, int i)
             return typeDeclarationType;
         }
 
-        private DeclarationType GetDeclarationType(FUNCDESC funcDesc, VarEnum funcValueType)
+        private DeclarationType GetDeclarationType(FUNCDESC funcDesc, VarEnum funcValueType, TYPEKIND typekind)
         {
             DeclarationType memberType;
             if (funcDesc.invkind.HasFlag(INVOKEKIND.INVOKE_PROPERTYGET))
@@ -283,7 +335,7 @@ private DeclarationType GetDeclarationType(FUNCDESC funcDesc, VarEnum funcValueT
             {
                 memberType = DeclarationType.Procedure;
             }
-            else if (funcDesc.funckind == FUNCKIND.FUNC_PUREVIRTUAL)
+            else if (funcDesc.funckind == FUNCKIND.FUNC_PUREVIRTUAL && typekind == TYPEKIND.TKIND_COCLASS)
             {
                 memberType = DeclarationType.Event;
             }

Rubberduck.Parsing/VBA/AttributeParser.cs

@@ -9,14 +9,6 @@
 
 namespace Rubberduck.Parsing.VBA
 {
-    /// <summary>
-    /// A dictionary storing values for a given attribute.
-    /// </summary>
-    /// <remarks>
-    /// Dictionary key is the attribute name/identifier.
-    /// </remarks>
-    public class Attributes : Dictionary<string, IEnumerable<string>> { }
-
     public class AttributeParser : IAttributeParser
     {
         private readonly IModuleExporter _exporter;

Rubberduck.Parsing/VBA/Attributes.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+
+namespace Rubberduck.Parsing.VBA
+{
+    /// <summary>
+    /// A dictionary storing values for a given attribute.
+    /// </summary>
+    /// <remarks>
+    /// Dictionary key is the attribute name/identifier.
+    /// </remarks>
+    public class Attributes : Dictionary<string, IEnumerable<string>>
+    {
+        /// <summary>
+        /// Specifies that a member is the type's default member.
+        /// Only one member in the type is allowed to have this attribute.
+        /// </summary>
+        /// <param name="identifierName"></param>
+        public void AddDefaultMemberAttribute(string identifierName)
+        {
+            Add(identifierName + ".VB_UserMemId", new[] {"0"});
+        }
+
+        public void AddHiddenMemberAttribute(string identifierName)
+        {
+            Add(identifierName + ".VB_UserMemId", new[] {"40"});
+        }
+
+        public void AddEnumeratorMemberAttribute(string identifierName)
+        {
+            Add(identifierName + ".VB_UserMemId", new[] {"-4"});
+        }
+
+        public void AddMemberDescriptionAttribute(string identifierName, string description)
+        {
+            Add(identifierName + ".VB_Description", new[] {description});
+        }
+
+        public void AddPredeclaredIdTypeAttribute()
+        {
+            Add("VB_PredeclaredId", new[] {"True"});
+        }
+    }
+}