Merge pull request #1882 from Hosch250/Issue1853

Make Worksheets and Workbooks know what type they are.

Author: Hosch250

Rubberduck.Parsing/Symbols/ClassModuleDeclaration.cs

@@ -18,7 +18,8 @@ public ClassModuleDeclaration(
                   string name,
                   bool isBuiltIn,
                   IEnumerable<IAnnotation> annotations,
-                  Attributes attributes, bool hasDefaultInstanceVariable = false)
+                  Attributes attributes,
+                  bool hasDefaultInstanceVariable = false)
             : base(
                   qualifiedName,
                   projectDeclaration,

Rubberduck.Parsing/Symbols/DeclarationSymbolsListener.cs

@@ -8,12 +8,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.InteropServices;
 using Antlr4.Runtime.Misc;
 
 namespace Rubberduck.Parsing.Symbols
 {
     public class DeclarationSymbolsListener : VBAParserBaseListener
     {
+        private readonly RubberduckParserState _state;
         private readonly QualifiedModuleName _qualifiedName;
         private readonly Declaration _moduleDeclaration;
         private readonly Declaration _projectDeclaration;
@@ -22,33 +24,29 @@ public class DeclarationSymbolsListener : VBAParserBaseListener
         private Declaration _currentScopeDeclaration;
         private Declaration _parentDeclaration;
 
-        private readonly IEnumerable<CommentNode> _comments;
         private readonly IEnumerable<IAnnotation> _annotations;
         private readonly IDictionary<Tuple<string, DeclarationType>, Attributes> _attributes;
-        private readonly HashSet<ReferencePriorityMap> _projectReferences;
 
         private readonly List<Declaration> _createdDeclarations = new List<Declaration>();
         public IReadOnlyList<Declaration> CreatedDeclarations { get { return _createdDeclarations; } }
 
         public DeclarationSymbolsListener(
+            RubberduckParserState state,
             QualifiedModuleName qualifiedName,
             vbext_ComponentType type,
-            IEnumerable<CommentNode> comments,
             IEnumerable<IAnnotation> annotations,
             IDictionary<Tuple<string, DeclarationType>, Attributes> attributes,
-            HashSet<ReferencePriorityMap> projectReferences,
             Declaration projectDeclaration)
         {
+            _state = state;
             _qualifiedName = qualifiedName;
-            _comments = comments;
             _annotations = annotations;
             _attributes = attributes;
 
             var declarationType = type == vbext_ComponentType.vbext_ct_StdModule
                 ? DeclarationType.ProceduralModule
                 : DeclarationType.ClassModule;
 
-            _projectReferences = projectReferences;
             _projectDeclaration = projectDeclaration;
 
             var key = Tuple.Create(_qualifiedName.ComponentName, declarationType);
@@ -69,6 +67,41 @@ public DeclarationSymbolsListener(
             else
             {
                 bool hasDefaultInstanceVariable = type != vbext_ComponentType.vbext_ct_ClassModule && type != vbext_ComponentType.vbext_ct_StdModule;
+
+                Declaration superType = null;
+                if (type == vbext_ComponentType.vbext_ct_Document)
+                {
+                    foreach (var coclass in _state.CoClasses)
+                    {
+                        try
+                        {
+                            if (coclass.Key.Count != _qualifiedName.Component.Properties.Count)
+                            {
+                                continue;
+                            }
+
+                            var allNamesMatch = true;
+                            for (var i = 0; i < coclass.Key.Count; i++)
+                            {
+                                if (coclass.Key[i] != _qualifiedName.Component.Properties.Item(i + 1).Name)
+                                {
+                                    allNamesMatch = false;
+                                    break;
+                                }
+                            }
+                            
+                            if (allNamesMatch)
+                            {
+                                superType = coclass.Value;
+                                break;
+                            }
+                        }
+                        catch (COMException)
+                        {
+                        }
+                    }
+                }
+
                 _moduleDeclaration = new ClassModuleDeclaration(
                     _qualifiedName.QualifyMemberName(_qualifiedName.Component.Name),
                     _projectDeclaration,
@@ -77,6 +110,11 @@ public DeclarationSymbolsListener(
                     FindAnnotations(),
                     moduleAttributes,
                     hasDefaultInstanceVariable: hasDefaultInstanceVariable);
+
+                if (superType != null)
+                {
+                    ((ClassModuleDeclaration) _moduleDeclaration).AddSupertype(superType);
+                }
             }
             SetCurrentScope();
             AddDeclaration(_moduleDeclaration);

Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs

@@ -284,6 +284,11 @@ public List<Declaration> GetDeclarationsForReference(Reference reference)
 
             foreach (var member in _comInformation.Values)
             {
+                if (member.TypeAttributes.typekind == TYPEKIND.TKIND_COCLASS)
+                {
+                    GetCoClassInformation(member);
+                }
+
                 for (var memberIndex = 0; memberIndex < member.TypeAttributes.cFuncs; memberIndex++)
                 {
                     string[] memberNames;
@@ -299,6 +304,7 @@ public List<Declaration> GetDeclarationsForReference(Reference reference)
                         member.TypeInfo.ReleaseFuncDesc(memberDescriptorPointer);
                         continue;
                     }
+
                     if (member.ModuleDeclaration.DeclarationType == DeclarationType.ClassModule &&
                         memberDeclaration is ICanBeDefaultMember &&
                         ((ICanBeDefaultMember)memberDeclaration).IsDefaultMember)
@@ -338,6 +344,53 @@ memberDeclaration is ICanBeDefaultMember &&
             return output;
         }
 
+        private void GetCoClassInformation(ComInformation member)
+        {
+            var componentMemberNames = new List<string>();
+            for (var implIndex = 0; implIndex < member.TypeAttributes.cImplTypes; implIndex++)
+            {
+                int href;
+                member.TypeInfo.GetRefTypeOfImplType(0, out href);
+
+                ITypeInfo implTypeInfo;
+                member.TypeInfo.GetRefTypeInfo(href, out implTypeInfo);
+
+                IntPtr typeAttributesPointer;
+                implTypeInfo.GetTypeAttr(out typeAttributesPointer);
+
+                var typeAttributes = (TYPEATTR)Marshal.PtrToStructure(typeAttributesPointer, typeof(TYPEATTR));
+
+                for (var i = 0; i < typeAttributes.cFuncs; i++)
+                {
+                    var memberNames = new string[255];
+
+                    IntPtr memberDescriptorPointer;
+                    implTypeInfo.GetFuncDesc(i, out memberDescriptorPointer);
+                    var memberDescriptor = (FUNCDESC)Marshal.PtrToStructure(memberDescriptorPointer, typeof(FUNCDESC));
+
+                    if (!(memberDescriptor.invkind.HasFlag(INVOKEKIND.INVOKE_PROPERTYGET) ||
+                        memberDescriptor.invkind.HasFlag(INVOKEKIND.INVOKE_PROPERTYPUT) ||
+                        memberDescriptor.invkind.HasFlag(INVOKEKIND.INVOKE_PROPERTYPUTREF)))
+                    {
+                        continue;
+                    }
+
+                    int namesArrayLength;
+                    implTypeInfo.GetNames(memberDescriptor.memid, memberNames, 255, out namesArrayLength);
+
+                    if (!IgnoredInterfaceMembers.Contains(memberNames[0]) &&
+                        !componentMemberNames.Contains(memberNames[0]))
+                    {
+                        componentMemberNames.Add(memberNames[0]);
+                    }
+                }
+
+                member.TypeInfo.ReleaseTypeAttr(typeAttributesPointer);
+            }
+
+            _state.CoClasses.TryAdd(componentMemberNames, member.ModuleDeclaration);
+        }
+
         private Declaration CreateMemberDeclaration(FUNCDESC memberDescriptor, TYPEKIND typeKind, ITypeInfo info, IMPLTYPEFLAGS parentImplFlags,
             QualifiedModuleName typeQualifiedModuleName, Declaration moduleDeclaration, out string[] memberNames)
         {

Rubberduck.Parsing/VBA/RubberduckParser.cs

@@ -566,7 +566,7 @@ private void ResolveDeclarations(VBComponent component, IParseTree tree)
                     }
                 }
                 Logger.Debug("Creating declarations for module {0}.", qualifiedModuleName.Name);
-                var declarationsListener = new DeclarationSymbolsListener(qualifiedModuleName, component.Type, _state.GetModuleComments(component), _state.GetModuleAnnotations(component), _state.GetModuleAttributes(component), _projectReferences, projectDeclaration);
+                var declarationsListener = new DeclarationSymbolsListener(_state, qualifiedModuleName, component.Type, _state.GetModuleAnnotations(component), _state.GetModuleAttributes(component), projectDeclaration);
                 ParseTreeWalker.Default.Walk(declarationsListener, tree);
                 foreach (var createdDeclaration in declarationsListener.CreatedDeclarations)
                 {

Rubberduck.Parsing/VBA/RubberduckParserState.cs

@@ -67,6 +67,8 @@ public sealed class RubberduckParserState : IDisposable
 
         private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
 
+        public readonly ConcurrentDictionary<List<string>, Declaration> CoClasses = new ConcurrentDictionary<List<string>, Declaration>();
+
         static RubberduckParserState()
         {
             var values = Enum.GetValues(typeof(ParserState));
@@ -1032,6 +1034,11 @@ public void Dispose()
                 item.Value.Dispose();
             }
 
+            if (CoClasses != null)
+            {
+                CoClasses.Clear();
+            }
+
             _moduleStates.Clear();
             _declarationSelections.Clear();
             _projects.Clear();