Merge pull request #205 from rubberduck-vba/next

sync with main repo

RetailCoder.VBE/Root/RubberduckModule.cs

@@ -7,6 +7,7 @@
 using Ninject.Modules;
 using Rubberduck.Common;
 using Rubberduck.Parsing;
+using Rubberduck.Parsing.ComReflection;
 using Rubberduck.Parsing.Symbols.DeclarationLoaders;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Settings;

RetailCoder.VBE/UI/Command/MenuItems/CommandBars/SerializeDeclarationsCommandMenuItem.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using NLog;
+using Rubberduck.Parsing.ComReflection;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.SettingsProvider;

Rubberduck.Parsing/ComReflection/ComCoClass.cs

@@ -41,6 +41,11 @@ public IEnumerable<ComMember> Members
             get { return ImplementedInterfaces.Where(x => !_events.Contains(x)).SelectMany(i => i.Members); }
         }
 
+        public ComMember DefaultMember
+        {
+            get { return DefaultInterface.DefaultMember; }
+        }
+
         public IEnumerable<ComMember> SourceMembers
         {
             get { return _events.SelectMany(i => i.Members); }

Rubberduck.Parsing/ComReflection/ComField.cs

@@ -1,7 +1,6 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
-using System.Xml.Schema;
 using Rubberduck.Parsing.Symbols;
 using VARDESC = System.Runtime.InteropServices.ComTypes.VARDESC;
 using VARFLAGS = System.Runtime.InteropServices.ComTypes.VARFLAGS;

Rubberduck.Parsing/ComReflection/ComInterface.cs

@@ -16,6 +16,7 @@ public class ComInterface : ComType, IComTypeWithMembers
     {
         private readonly List<ComInterface> _inherited = new List<ComInterface>();
         private readonly List<ComMember> _members = new List<ComMember>();
+        private ComMember _defaultMember;
 
         public bool IsExtensible { get; private set; }
 
@@ -29,6 +30,11 @@ public IEnumerable<ComMember> Members
             get { return _members; }
         }
 
+        public ComMember DefaultMember
+        {
+            get { return _defaultMember; }
+        }
+
         public ComInterface(ITypeInfo info, TYPEATTR attrib) : base(info, attrib)
         {
             GetImplementedInterfaces(info, attrib);
@@ -78,7 +84,12 @@ private void GetComMembers(ITypeInfo info, TYPEATTR attrib)
                 {
                     continue;
                 }
-                _members.Add(new ComMember(info, member));
+                var comMember = new ComMember(info, member);
+                _members.Add(comMember);
+                if (comMember.IsDefault)
+                {
+                    _defaultMember = comMember;
+                }
                 info.ReleaseFuncDesc(memberPtr);
             }
         }

Rubberduck.Parsing/ComReflection/ComMember.cs

@@ -12,6 +12,18 @@
 
 namespace Rubberduck.Parsing.ComReflection
 {
+    internal enum DispId
+    {
+        Collect = -8,           //The method you are calling through Invoke is an accessor function. 
+        Destructor = -7,        //The C++ destructor function for the object. 
+        Construtor = -6,        //The C++ constructor function for the object. 
+        Evaluate = -5,          //This method is implicitly invoked when the ActiveX client encloses the arguments in square brackets.
+        NewEnum = -4,           //It returns an enumerator object that supports IEnumVARIANT.
+        PropertyPut = -3,       //The parameter that receives the value of an assignment in a PROPERTYPUT. 
+        Unknown = -1,           //The value returned by IDispatch::GetIDsOfNames to indicate that a member or parameter name was not found.
+        Value = 0               //The default member for the object.
+    }
+
     [DebuggerDisplay("{MemberDeclaration}")]
     public class ComMember : ComBase
     {
@@ -20,6 +32,8 @@ public class ComMember : ComBase
         public bool ReturnsWithEventsObject { get; private set; }
         public bool IsDefault { get; private set; }
         public bool IsEnumerator { get; private set; }
+        //This member is called on an interface when a bracketed expression is dereferenced.
+        public bool IsEvaluateFunction { get; private set; }
         public ComParameter ReturnType { get; private set; }
         public List<ComParameter> Parameters { get; set; }
 
@@ -30,8 +44,9 @@ public ComMember(ITypeInfo info, FUNCDESC funcDesc) : base(info, funcDesc)
             IsHidden = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FHIDDEN);
             IsRestricted = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FRESTRICTED);
             ReturnsWithEventsObject = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FSOURCE);
-            IsDefault = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FUIDEFAULT);
-            IsEnumerator = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FNONBROWSABLE) && Name.Equals("_NewEnum");
+            IsDefault = Index == (int)DispId.Value;
+            IsEnumerator = Index == (int)DispId.NewEnum;
+            IsEvaluateFunction = Index == (int)DispId.Evaluate;
             SetDeclarationType(funcDesc, info);
         }
 

Rubberduck.Parsing/ComReflection/ComModule.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
 using Rubberduck.Parsing.Symbols;
@@ -20,6 +19,11 @@ public IEnumerable<ComMember> Members
             get { return _members; }
         }
 
+        public ComMember DefaultMember
+        {
+            get { return null; }
+        }
+
         private readonly List<ComField> _fields = new List<ComField>();
         public IEnumerable<ComField> Fields
         {

Rubberduck.Parsing/ComReflection/ComProject.cs

@@ -120,8 +120,6 @@ private void LoadModules(ITypeLib typeLibrary)
                             if (type != null) KnownTypes.TryAdd(typeAttributes.guid, coclass);
                             break;
                         case TYPEKIND.TKIND_ALIAS:
-                        case TYPEKIND.TKIND_UNION:
-
                         //The current handling of this is wrong - these don't have to be classes or interfaces. In the VBE module for example,
                             //"LongPtr" is defined as an alias to "Long" (at least on a 32 bit system) - RD is currently treating is like a class.  
                             //Unclear if these can *also* define alternative names for interfaces as well, but all the ones I've seen have been basically
@@ -141,6 +139,9 @@ private void LoadModules(ITypeLib typeLibrary)
                             _modules.Add(module as ComModule);
                             if (type != null) KnownTypes.TryAdd(typeAttributes.guid, module);
                             break;
+                        case TYPEKIND.TKIND_UNION:
+                            //TKIND_UNION is not a supported member type in VBA.
+                            break;
                         default:
                             throw new NotImplementedException(string.Format("Didn't expect a TYPEATTR with multiple typekind flags set in {0}.", Path));
                     }

Rubberduck.Parsing/ComReflection/ComType.cs

@@ -9,12 +9,13 @@ public interface IComType : IComBase
         bool IsAppObject { get; }
         bool IsPreDeclared { get; }
         bool IsHidden { get; }
-        bool IsRestricted { get; }        
+        bool IsRestricted { get; }       
     }
 
     public interface IComTypeWithMembers : IComType
     {
         IEnumerable<ComMember> Members { get; }
+        ComMember DefaultMember { get; }
     }
 
     public interface IComTypeWithFields : IComType

Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs → Rubberduck.Parsing/ComReflection/ReferencedDeclarationsCollector.cs

@@ -2,15 +2,15 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
-using Rubberduck.Parsing.ComReflection;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
-using System.Linq;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
-namespace Rubberduck.Parsing.Symbols
+namespace Rubberduck.Parsing.ComReflection
 {
     public class ReferencedDeclarationsCollector
     {
@@ -139,29 +139,19 @@ public List<Declaration> LoadDeclarationsFromLibrary()
                         ? string.Format("_{0}", module.Name)
                         : module.Name);
 
-                var attributes = new Attributes();
-                if (module.IsPreDeclared)
-                {
-                    attributes.AddPredeclaredIdTypeAttribute();
-                }
-                if (module.IsAppObject)
-                {
-                    attributes.AddGlobalClassAttribute();
-                }
-
-                var declaration = CreateModuleDeclaration(module, moduleName, project, attributes);
+                var declaration = CreateModuleDeclaration(module, moduleName, project, GetModuleAttributes(module));
                 var moduleTree = new SerializableDeclarationTree(declaration);
                 _declarations.Add(declaration);
                 _serialized.AddDeclaration(moduleTree);
 
                 var membered = module as IComTypeWithMembers;
                 if (membered != null)
                 {
-                    CreateMemberDeclarations(membered.Members, moduleName, declaration, moduleTree);
+                    CreateMemberDeclarations(membered.Members, moduleName, declaration, moduleTree, membered.DefaultMember);
                     var coClass = membered as ComCoClass;
                     if (coClass != null)
                     {
-                        CreateMemberDeclarations(coClass.SourceMembers, moduleName, declaration, moduleTree, true);
+                        CreateMemberDeclarations(coClass.SourceMembers, moduleName, declaration, moduleTree, coClass.DefaultMember, true);
                     }
                 }
 
@@ -204,8 +194,26 @@ public List<Declaration> LoadDeclarationsFromLibrary()
             return _declarations;
         }
 
+        private static Attributes GetModuleAttributes(IComType module)
+        {
+            var attributes = new Attributes();
+            if (module.IsPreDeclared)
+            {
+                attributes.AddPredeclaredIdTypeAttribute();
+            }
+            if (module.IsAppObject)
+            {
+                attributes.AddGlobalClassAttribute();
+            }
+            if (module as ComInterface != null && ((ComInterface)module).IsExtensible)
+            {
+                attributes.AddExtensibledClassAttribute();
+            }
+            return attributes;
+        }
+
         private void CreateMemberDeclarations(IEnumerable<ComMember> members, QualifiedModuleName moduleName, Declaration declaration,
-                                              SerializableDeclarationTree moduleTree, bool eventHandlers = false)
+                                              SerializableDeclarationTree moduleTree, ComMember defaultMember, bool eventHandlers = false)
         {
             foreach (var item in members.Where(m => !m.IsRestricted && !IgnoredInterfaceMembers.Contains(m.Name)))
             {
@@ -222,7 +230,7 @@ public List<Declaration> LoadDeclarationsFromLibrary()
                     memberTree.AddChildren(hasParams.Parameters);
                 }
                 var coClass = memberDeclaration as ClassModuleDeclaration;
-                if (coClass != null && item.IsDefault)
+                if (coClass != null && item == defaultMember)
                 {
                     coClass.DefaultMember = memberDeclaration;
                 }
@@ -262,20 +270,7 @@ private Declaration CreateModuleDeclaration(IComType module, QualifiedModuleName
 
         private Declaration CreateMemberDeclaration(ComMember member, QualifiedModuleName module, Declaration parent, bool handler)
         {
-            var attributes = new Attributes();
-            if (member.IsEnumerator)
-            {
-                attributes.AddEnumeratorMemberAttribute(member.Name);
-            }
-            else if (member.IsDefault)
-            {
-                attributes.AddDefaultMemberAttribute(member.Name);
-            }
-            else if (member.IsHidden)
-            {
-                attributes.AddHiddenMemberAttribute(member.Name);
-            }
-
+            var attributes = GetMemberAttibutes(member);
             switch (member.Type)
             {
                 case DeclarationType.Procedure:
@@ -292,5 +287,27 @@ private Declaration CreateMemberDeclaration(ComMember member, QualifiedModuleNam
                     throw new InvalidEnumArgumentException(string.Format("Unexpected DeclarationType {0} encountered.", member.Type));
             }
         }
+
+        private static Attributes GetMemberAttibutes(ComMember member)
+        {
+            var attributes = new Attributes();
+            if (member.IsEnumerator)
+            {
+                attributes.AddEnumeratorMemberAttribute(member.Name);
+            }
+            else if (member.IsDefault)
+            {
+                attributes.AddDefaultMemberAttribute(member.Name);
+            }
+            else if (member.IsHidden)
+            {
+                attributes.AddHiddenMemberAttribute(member.Name);
+            }
+            else if (member.IsEvaluateFunction)
+            {
+                attributes.AddEvaluateMemberAttribute(member.Name);
+            }
+            return attributes;
+        }
     }
 }

Rubberduck.Parsing/Symbols/SerializableDeclaration.cs → Rubberduck.Parsing/ComReflection/SerializableDeclaration.cs

@@ -2,10 +2,11 @@
 using System.Linq;
 using System.Runtime.Serialization;
 using Rubberduck.Parsing.Annotations;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.VBEditor;
 
-namespace Rubberduck.Parsing.Symbols
+namespace Rubberduck.Parsing.ComReflection
 {
     public class SerializableDeclarationTree
     {
@@ -176,12 +177,6 @@ public SerializableDeclaration(Declaration declaration)
                 IsByRefParam = param.IsByRef;
                 IsParamArray = param.IsParamArray;
             }
-
-            var canExtend = declaration as ClassModuleDeclaration;
-            if (canExtend != null)
-            {
-                IsExtensible = canExtend.IsExtensible;
-            }
         }
 
         public List<SerializableMemberAttribute> Attributes { get; set; }
@@ -225,7 +220,7 @@ public Declaration Unwrap(Declaration parent)
                 case DeclarationType.Project:
                     return new ProjectDeclaration(QualifiedMemberName, IdentifierName, true, null);                    
                 case DeclarationType.ClassModule:
-                    return new ClassModuleDeclaration(QualifiedMemberName, parent, IdentifierName, true, annotations, attributes) { IsExtensible = IsExtensible };
+                    return new ClassModuleDeclaration(QualifiedMemberName, parent, IdentifierName, true, annotations, attributes);
                 case DeclarationType.ProceduralModule:
                     return new ProceduralModuleDeclaration(QualifiedMemberName, parent, IdentifierName, true, annotations, attributes);
                 case DeclarationType.Procedure:

Rubberduck.Parsing/Symbols/XmlPersistableDeclarations.cs → Rubberduck.Parsing/ComReflection/XmlPersistableDeclarations.cs

@@ -1,12 +1,11 @@
 using System;
 using System.IO;
-using System.Runtime.InteropServices.ComTypes;
 using System.Runtime.Serialization;
 using System.Text;
 using System.Xml;
 using Rubberduck.SettingsProvider;
 
-namespace Rubberduck.Parsing.Symbols
+namespace Rubberduck.Parsing.ComReflection
 {
     public class XmlPersistableDeclarations : IPersistable<SerializableProject>
     {

Rubberduck.Parsing/Rubberduck.Parsing.csproj

@@ -258,7 +258,7 @@
     <Compile Include="Symbols\PropertyGetDeclaration.cs" />
     <Compile Include="Symbols\FunctionDeclaration.cs" />
     <Compile Include="Symbols\DeclarationLoaders\RubberduckApiDeclarations.cs" />
-    <Compile Include="Symbols\SerializableDeclaration.cs" />
+    <Compile Include="ComReflection\SerializableDeclaration.cs" />
     <Compile Include="Symbols\SquareBracketedNameComparer.cs" />
     <Compile Include="Symbols\SubroutineDeclaration.cs" />
     <Compile Include="Symbols\ProjectReferencePass.cs" />
@@ -272,7 +272,7 @@
     <Compile Include="Symbols\ProceduralModuleDeclaration.cs" />
     <Compile Include="Symbols\ProjectDeclaration.cs" />
     <Compile Include="Symbols\ProjectReference.cs" />
-    <Compile Include="Symbols\ReferencedDeclarationsCollector.cs" />
+    <Compile Include="ComReflection\ReferencedDeclarationsCollector.cs" />
     <Compile Include="Symbols\SyntaxErrorException.cs" />
     <Compile Include="ParserRuleContextExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -284,7 +284,7 @@
     <Compile Include="Symbols\IdentifierReference.cs" />
     <Compile Include="Symbols\IdentifierReferenceListener.cs" />
     <Compile Include="Symbols\ConstantDeclaration.cs" />
-    <Compile Include="Symbols\XmlPersistableDeclarations.cs" />
+    <Compile Include="ComReflection\XmlPersistableDeclarations.cs" />
     <Compile Include="Syntax\SyntaxTree.cs" />
     <Compile Include="Syntax\TextSpan.cs" />
     <Compile Include="VBA\AttributeParser.cs" />