sync with main repo

RetailCoder.VBE/Inspections/MemberNotOnInterfaceInspection.cs

@@ -18,9 +18,7 @@ public sealed class MemberNotOnInterfaceInspection : InspectionBase
         private static readonly List<Type> InterestingTypes = new List<Type>
         {
             typeof(VBAParser.MemberAccessExprContext),
-            typeof(VBAParser.WithMemberAccessExprContext),
-            typeof(VBAParser.DictionaryAccessExprContext),
-            typeof(VBAParser.WithDictionaryAccessExprContext)
+            typeof(VBAParser.WithMemberAccessExprContext)
         }; 
 
         public MemberNotOnInterfaceInspection(RubberduckParserState state, CodeInspectionSeverity defaultSeverity = CodeInspectionSeverity.Warning)
@@ -34,7 +32,8 @@ public MemberNotOnInterfaceInspection(RubberduckParserState state, CodeInspectio
 
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
-            var targets = Declarations.Where(decl => decl.AsTypeDeclaration != null && 
+            var targets = Declarations.Where(decl => decl.AsTypeDeclaration != null &&
+                                                     decl.ParentDeclaration.DeclarationType != DeclarationType.Project &&
                                                      decl.AsTypeDeclaration.DeclarationType == DeclarationType.ClassModule &&
                                                      ((ClassModuleDeclaration)decl.AsTypeDeclaration).IsExtensible &&
                                                      decl.References.Any(usage => InterestingTypes.Contains(usage.Context.Parent.GetType())))

Rubberduck.Parsing/ComReflection/ComCoClass.cs

@@ -38,7 +38,12 @@ public IEnumerable<ComInterface> VisibleInterfaces
 
         public IEnumerable<ComMember> Members
         {
-            get { return ImplementedInterfaces.SelectMany(i => i.Members); }
+            get { return ImplementedInterfaces.Where(x => !_events.Contains(x)).SelectMany(i => i.Members); }
+        }
+
+        public IEnumerable<ComMember> SourceMembers
+        {
+            get { return _events.SelectMany(i => i.Members); }
         }
 
         public bool WithEvents

Rubberduck.Parsing/ComReflection/ComMember.cs

@@ -17,7 +17,7 @@ public class ComMember : ComBase
     {
         public bool IsHidden { get; private set; }
         public bool IsRestricted { get; private set; }
-        public bool IsEventHandler { get; private set; }
+        public bool ReturnsWithEventsObject { get; private set; }
         public bool IsDefault { get; private set; }
         public bool IsEnumerator { get; private set; }
         public ComParameter ReturnType { get; private set; }
@@ -29,18 +29,14 @@ public ComMember(ITypeInfo info, FUNCDESC funcDesc) : base(info, funcDesc)
             var flags = (FUNCFLAGS)funcDesc.wFuncFlags;
             IsHidden = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FHIDDEN);
             IsRestricted = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FRESTRICTED);
-            IsEventHandler = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FSOURCE);
+            ReturnsWithEventsObject = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FSOURCE);
             IsDefault = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FUIDEFAULT);
             IsEnumerator = flags.HasFlag(FUNCFLAGS.FUNCFLAG_FNONBROWSABLE) && Name.Equals("_NewEnum");
             SetDeclarationType(funcDesc, info);
         }
 
         private void SetDeclarationType(FUNCDESC funcDesc, ITypeInfo info)
         {
-            if (IsEventHandler)
-            {
-                Type = DeclarationType.Event;
-            }
             if (funcDesc.invkind.HasFlag(INVOKEKIND.INVOKE_PROPERTYGET))
             {
                 Type = DeclarationType.PropertyGet;

Rubberduck.Parsing/ComReflection/ComModule.cs

@@ -1,6 +1,7 @@
 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;

Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs

@@ -156,25 +156,11 @@ public List<Declaration> LoadDeclarationsFromLibrary()
                 var membered = module as IComTypeWithMembers;
                 if (membered != null)
                 {
-                    foreach (var item in membered.Members.Where(m => !m.IsRestricted && !IgnoredInterfaceMembers.Contains(m.Name)))
+                    CreateMemberDeclarations(membered.Members, moduleName, declaration, moduleTree);
+                    var coClass = membered as ComCoClass;
+                    if (coClass != null)
                     {
-                        var memberDeclaration = CreateMemberDeclaration(item, moduleName, declaration);
-                        _declarations.Add(memberDeclaration);
-
-                        var memberTree = new SerializableDeclarationTree(memberDeclaration);
-                        moduleTree.AddChildTree(memberTree); 
-
-                        var hasParams = memberDeclaration as IDeclarationWithParameter;
-                        if (hasParams != null)
-                        {
-                            _declarations.AddRange(hasParams.Parameters);
-                            memberTree.AddChildren(hasParams.Parameters);
-                        }
-                        var coClass = memberDeclaration as ClassModuleDeclaration;
-                        if (coClass != null && item.IsDefault)
-                        {
-                            coClass.DefaultMember = memberDeclaration;
-                        }
+                        CreateMemberDeclarations(coClass.SourceMembers, moduleName, declaration, moduleTree, true);
                     }
                 }
 
@@ -217,6 +203,31 @@ public List<Declaration> LoadDeclarationsFromLibrary()
             return _declarations;
         }
 
+        private void CreateMemberDeclarations(IEnumerable<ComMember> members, QualifiedModuleName moduleName, Declaration declaration,
+                                              SerializableDeclarationTree moduleTree, bool eventHandlers = false)
+        {
+            foreach (var item in members.Where(m => !m.IsRestricted && !IgnoredInterfaceMembers.Contains(m.Name)))
+            {
+                var memberDeclaration = CreateMemberDeclaration(item, moduleName, declaration, eventHandlers);
+                _declarations.Add(memberDeclaration);
+
+                var memberTree = new SerializableDeclarationTree(memberDeclaration);
+                moduleTree.AddChildTree(memberTree);
+
+                var hasParams = memberDeclaration as IDeclarationWithParameter;
+                if (hasParams != null)
+                {
+                    _declarations.AddRange(hasParams.Parameters);
+                    memberTree.AddChildren(hasParams.Parameters);
+                }
+                var coClass = memberDeclaration as ClassModuleDeclaration;
+                if (coClass != null && item.IsDefault)
+                {
+                    coClass.DefaultMember = memberDeclaration;
+                }
+            }
+        }
+
         private Declaration CreateModuleDeclaration(IComType module, QualifiedModuleName project, Declaration parent, Attributes attributes)
         {
             var enumeration = module as ComEnumeration;
@@ -248,7 +259,7 @@ private Declaration CreateModuleDeclaration(IComType module, QualifiedModuleName
             return new ProceduralModuleDeclaration(module as ComModule, parent, project, attributes);
         }
 
-        private Declaration CreateMemberDeclaration(ComMember member, QualifiedModuleName module, Declaration parent)
+        private Declaration CreateMemberDeclaration(ComMember member, QualifiedModuleName module, Declaration parent, bool handler)
         {
             var attributes = new Attributes();
             if (member.IsEnumerator)
@@ -266,9 +277,8 @@ private Declaration CreateMemberDeclaration(ComMember member, QualifiedModuleNam
 
             switch (member.Type)
             {
-                case DeclarationType.Event:
                 case DeclarationType.Procedure:
-                    return new SubroutineDeclaration(member, parent, module, attributes);
+                    return new SubroutineDeclaration(member, parent, module, attributes, handler);
                 case DeclarationType.Function:
                     return new FunctionDeclaration(member, parent, module, attributes);
                 case DeclarationType.PropertyGet:

Rubberduck.Parsing/Symbols/SubroutineDeclaration.cs

@@ -45,18 +45,24 @@ public SubroutineDeclaration(
         }
 
         public SubroutineDeclaration(ComMember member, Declaration parent, QualifiedModuleName module,
-            Attributes attributes)
-            : this(
-                module.QualifyMemberName(member.Name),
-                parent,
-                parent,
-                string.Empty,
-                Accessibility.Global,
-                null,
-                Selection.Home,
-                true,
-                null,
-                attributes)
+            Attributes attributes, bool eventHandler)
+            : base(
+                  module.QualifyMemberName(member.Name),
+                  parent,
+                  parent,
+                  string.Empty,
+                  null,
+                  false,
+                  false,
+                  Accessibility.Global,
+                  eventHandler ? DeclarationType.Event : DeclarationType.Procedure,
+                  null,
+                  Selection.Home,
+                  false,
+                  null,
+                  true,
+                  null,
+                  attributes)
         {
             _parameters =
                 member.Parameters.Select(decl => new ParameterDeclaration(decl, this, module))