Get document supertypes from user com projects

We use the user com projects to get the names of the implemented interfaces; the type hierarchy pass does the rest.

There is one hack in this: we suppress the underscore in front of the implemented interfaces in order to emulate the VBE's behaviour to let type checks pass relative to the coclass instead of the interface. This is entirely based on convention.

Moreover, this lacks unit test since the com projects cannot be mocked at this stage.

Author: MDoerner

Rubberduck.Parsing/VBA/ReferenceManagement/CompilationPasses/TypeHierarchyPass.cs

@@ -31,12 +31,12 @@ public TypeHierarchyPass(DeclarationFinder declarationFinder, VBAExpressionParse
 
         public void Execute(IReadOnlyCollection<QualifiedModuleName> modules)
         {
-            var toRelsolveSupertypesFor = _declarationFinder.UserDeclarations(DeclarationType.ClassModule)
+            var toResolveSupertypesFor = _declarationFinder.UserDeclarations(DeclarationType.ClassModule)
                                             .Concat(_declarationFinder.UserDeclarations(DeclarationType.Document))
                                             .Concat(_declarationFinder.UserDeclarations(DeclarationType.UserForm))
                                             .Where(decl => modules.Contains(decl.QualifiedName.QualifiedModuleName))
                                             .Concat(_declarationFinder.BuiltInDeclarations(DeclarationType.ClassModule));
-            foreach (var declaration in toRelsolveSupertypesFor)
+            foreach (var declaration in toResolveSupertypesFor)
             {
                 AddImplementedInterface(declaration);
             }

Rubberduck.Parsing/VBA/ReferenceManagement/ReferenceResolveRunner.cs

@@ -5,6 +5,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Antlr4.Runtime.Tree;
+using Rubberduck.Parsing.ComReflection;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.VBEditor;
 
@@ -17,13 +18,15 @@ public class ReferenceResolveRunner : ReferenceResolveRunnerBase
         public ReferenceResolveRunner(
             RubberduckParserState state, 
             IParserStateManager parserStateManager, 
-            IModuleToModuleReferenceManager moduletToModuleReferenceManager,
-            IReferenceRemover referenceRemover) 
+            IModuleToModuleReferenceManager moduleToModuleReferenceManager,
+            IReferenceRemover referenceRemover,
+            IUserComProjectProvider userComProjectProvider) 
         :base(state, 
             parserStateManager, 
-            moduletToModuleReferenceManager,
-            referenceRemover)
-        { }
+            moduleToModuleReferenceManager,
+            referenceRemover,
+            userComProjectProvider)
+        {}
 
 
         protected override void ResolveReferences(ICollection<KeyValuePair<QualifiedModuleName, IParseTree>> toResolve, CancellationToken token)

Rubberduck.Parsing/VBA/ReferenceManagement/ReferenceResolveRunnerBase.cs

@@ -6,6 +6,7 @@
 using Antlr4.Runtime.Tree;
 using NLog;
 using Rubberduck.Parsing.Common;
+using Rubberduck.Parsing.ComReflection;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.Parsing.VBA.Extensions;
@@ -29,12 +30,14 @@ public abstract class ReferenceResolveRunnerBase : IReferenceResolveRunner
         protected readonly IParserStateManager _parserStateManager;
         private readonly IModuleToModuleReferenceManager _moduleToModuleReferenceManager;
         private readonly IReferenceRemover _referenceRemover;
+        private readonly IUserComProjectProvider _userComProjectProvider;
 
         public ReferenceResolveRunnerBase(
             RubberduckParserState state,
             IParserStateManager parserStateManager,
-            IModuleToModuleReferenceManager moduletToModuleReferenceManager,
-            IReferenceRemover referenceRemover)
+            IModuleToModuleReferenceManager moduleToModuleReferenceManager,
+            IReferenceRemover referenceRemover, 
+            IUserComProjectProvider userComProjectProvider)
         {
             if (state == null)
             {
@@ -44,19 +47,24 @@ public ReferenceResolveRunnerBase(
             {
                 throw new ArgumentNullException(nameof(parserStateManager));
             }
-            if (moduletToModuleReferenceManager == null)
+            if (moduleToModuleReferenceManager == null)
             {
-                throw new ArgumentNullException(nameof(moduletToModuleReferenceManager));
+                throw new ArgumentNullException(nameof(moduleToModuleReferenceManager));
             }
             if (referenceRemover == null)
             {
                 throw new ArgumentNullException(nameof(referenceRemover));
             }
+            if (userComProjectProvider == null)
+            {
+                throw new ArgumentNullException(nameof(userComProjectProvider));
+            }
 
             _state = state;
             _parserStateManager = parserStateManager;
-            _moduleToModuleReferenceManager = moduletToModuleReferenceManager;
+            _moduleToModuleReferenceManager = moduleToModuleReferenceManager;
             _referenceRemover = referenceRemover;
+            _userComProjectProvider = userComProjectProvider;
         }
 
 
@@ -81,18 +89,18 @@ public void ResolveReferences(IReadOnlyCollection<QualifiedModuleName> toResolve
 
             var parsingStageTimer = ParsingStageTimer.StartNew();
 
-            ExecuteCompilationPasses(_toResolve.AsReadOnly(), token);
+            AddSuperTypeNamesForDocumentModules(_toResolve.AsReadOnly(), _state, _userComProjectProvider);
             token.ThrowIfCancellationRequested();
 
             parsingStageTimer.Stop();
-            parsingStageTimer.Log("Executed compilation passes in {0}ms.");
-            parsingStageTimer.Restart();
+            parsingStageTimer.Log("Added supertypes for document modules in {0}ms.");
 
-            AddSupertypesForDocumentModules(_toResolve.AsReadOnly(), _state);
+            ExecuteCompilationPasses(_toResolve.AsReadOnly(), token);
             token.ThrowIfCancellationRequested();
 
             parsingStageTimer.Stop();
-            parsingStageTimer.Log("Added supertypes for document modules in {0}ms.");
+            parsingStageTimer.Log("Executed compilation passes in {0}ms.");
+            parsingStageTimer.Restart();
 
             var parseTreesToResolve = _state.ParseTrees.Where(kvp => _toResolve.Contains(kvp.Key)).ToList();
             token.ThrowIfCancellationRequested();
@@ -151,90 +159,46 @@ private void ExecuteCompilationPasses(IReadOnlyCollection<QualifiedModuleName> m
             }
         }
 
-        private void AddSupertypesForDocumentModules(IReadOnlyCollection<QualifiedModuleName> modules, RubberduckParserState state)
-        {
-            var documentModuleDeclarations = state.DeclarationFinder.UserDeclarations(DeclarationType.Document)
-                .OfType<DocumentModuleDeclaration>()
-                .Where(declaration => modules.Contains(declaration.QualifiedName.QualifiedModuleName));
-
-            foreach (var documentDeclaration in documentModuleDeclarations)
-            {
-                var documentSupertype = SupertypeForDocument(documentDeclaration.QualifiedName.QualifiedModuleName, state);
-                if (documentSupertype != null)
-                {
-                    documentDeclaration.AddSupertype(documentSupertype);
-                }
-            }
-        }
+        // skip IDispatch.. just about everything implements it and RD doesn't need to care about it; don't care about IUnknown either
+        private static readonly HashSet<string> IgnoredComInterfaces = new HashSet<string>(new[] { "IDispatch", "IUnknown" });
 
-        private Declaration SupertypeForDocument(QualifiedModuleName module, RubberduckParserState state)
+        private void AddSuperTypeNamesForDocumentModules(IReadOnlyCollection<QualifiedModuleName> modules, RubberduckParserState state, IUserComProjectProvider userComProjectProvider)
         {
-            if(module.ComponentType != ComponentType.Document)
-            {
-                return null;
-            }
+            //todo: Figure out how to unit test this.
 
-            var component = _state.ProjectsProvider.Component(module);
-            if (component == null || component.IsWrappingNullReference)
-            {
-                return null;
-            }
+            var documentModuleDeclarationsByProject = state.DeclarationFinder.UserDeclarations(DeclarationType.Document)
+                .OfType<DocumentModuleDeclaration>()
+                .Where(declaration => modules.Contains(declaration.QualifiedName.QualifiedModuleName))
+                .GroupBy(declaration => declaration.ProjectId);
 
-            Declaration superType = null;
-            // TODO: Replace with TypeLibAPI call, require a solution regarding thread synchronization or caching
-            /*
-            using (var properties = component.Properties)
+            foreach (var projectGroup in documentModuleDeclarationsByProject)
             {
-                int documentPropertyCount = 0;
-                try
+                var userComProject = userComProjectProvider.UserProject(projectGroup.Key);
+                var documents = projectGroup.ToDictionary(module => module.IdentifierName);
+                foreach (var comModule in userComProject.Members)
                 {
-                    if (properties == null || properties.IsWrappingNullReference)
+                    if (!(documents.TryGetValue(comModule.Name, out var document)))
                     {
-                        return null;
+                        continue;
                     }
-                    documentPropertyCount = properties.Count;
-                }
-                catch(COMException)
-                {
-                    return null;
-                }
-                
-                foreach (var coclass in state.CoClasses)
-                {
-                    try
-                    {
-                        if (coclass.Key.Count != documentPropertyCount)
-                        {
-                            continue;
-                        }
-
-                        var allNamesMatch = true;
-                        for (var i = 0; i < coclass.Key.Count; i++)
-                        {
-                            using (var property = properties[i+1])
-                            {
-                                if (coclass.Key[i] != property?.Name)
-                                {
-                                    allNamesMatch = false;
-                                    break;
-                                }
-                            }
-                        }
-
-                        if (allNamesMatch)
-                        {
-                            superType = coclass.Value;
-                            break;
-                        }
-                    }
-                    catch (COMException)
+
+                    var inheritedInterfaces = comModule is ComCoClass documentCoClass
+                        ? documentCoClass.ImplementedInterfaces
+                        : (comModule as ComInterface)?.InheritedInterfaces;
+
+                    //todo: Find a way to deal with the VBE's document type assignment behaviour not relying on an assumption about an interface naming convention. 
+                    var superTypeNames = inheritedInterfaces?
+                                             .Where(i => !i.IsRestricted && !IgnoredComInterfaces.Contains(i.Name))
+                                             .Select(i => i.Name)
+                                             .Select(name => name.StartsWith("_") ? name.Substring(1) : name) //This emulates the VBE's behaviour to allow assignment to the coclass type instead on the interface. 
+                                         ?? Enumerable.Empty<string>();
+
+                    foreach (var superTypeName in superTypeNames)
                     {
+                        document.AddSupertypeName(superTypeName);
                     }
                 }
             }
-            */
-
-            return superType;
         }
 
         protected void ResolveReferences(DeclarationFinder finder, QualifiedModuleName module, IParseTree tree, CancellationToken token)

Rubberduck.Parsing/VBA/ReferenceManagement/SynchronousReferenceResolveRunner.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using Antlr4.Runtime.Tree;
+using Rubberduck.Parsing.ComReflection;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
 using Rubberduck.VBEditor;
 
@@ -12,13 +13,15 @@ public class SynchronousReferenceResolveRunner : ReferenceResolveRunnerBase
         public SynchronousReferenceResolveRunner(
             RubberduckParserState state,
             IParserStateManager parserStateManager,
-            IModuleToModuleReferenceManager moduletToModuleReferenceManager,
-            IReferenceRemover referenceRemover)
+            IModuleToModuleReferenceManager moduleToModuleReferenceManager,
+            IReferenceRemover referenceRemover,
+            IUserComProjectProvider userComProjectProvider)
         : base(state,
             parserStateManager,
-            moduletToModuleReferenceManager,
-            referenceRemover)
-        { }
+            moduleToModuleReferenceManager,
+            referenceRemover,
+            userComProjectProvider)
+        {}
 
 
         protected override void ResolveReferences(ICollection<KeyValuePair<QualifiedModuleName, IParseTree>> toResolve, CancellationToken token)

RubberduckTests/Mocks/MockParser.cs

@@ -122,7 +122,8 @@ public static (SynchronousParseCoordinator parser, IRewritingManager rewritingMa
                 state,
                 parserStateManager,
                 moduleToModuleReferenceManager,
-                referenceRemover);
+                referenceRemover,
+                userComProjectsRepository);
             var parsingStageService = new ParsingStageService(
                 comSynchronizer,
                 builtInDeclarationLoader,