A viable proof of concept for providing CW-injected objects to COM consumers. RPS is used as a model, but subsequent PR will further encapsulate in order to only expose parser events to enable cache invalidation for type cache which must be outside the CW graph.

Author: bclothier

Rubberduck.Main/Extension.cs

@@ -230,7 +230,7 @@ private void Startup()
                 currentDomain.AssemblyResolve += LoadFromSameFolder;
 
                 _container = new WindsorContainer().Install(new RubberduckIoCInstaller(_vbe, _addin, _initialSettings, _vbeNativeApi, _beepInterceptor));
-                
+                _container.Resolve<InstanceProvider>();
                 _app = _container.Resolve<App>();
                 _app.Startup();
 

Rubberduck.Main/Root/InstanceProvider.cs

@@ -0,0 +1,27 @@
+using System;
+using Rubberduck.Parsing.VBA;
+
+namespace Rubberduck.Root
+{
+    public interface IInstanceProvider
+    {
+        RubberduckParserState StateInstance { get; }
+    }
+
+    public static class InstanceProviderFactory
+    {
+        public static IInstanceProvider GetInstanceProvider => new InstanceProvider();
+    }
+
+    internal class InstanceProvider : IInstanceProvider
+    {
+        private static RubberduckParserState _stateInstance;
+        public static RubberduckParserState StateInstance
+        {
+            get => _stateInstance;
+            set => _stateInstance = value ?? throw new NullReferenceException();
+        }
+
+        RubberduckParserState IInstanceProvider.StateInstance => _stateInstance;
+    }
+}

Rubberduck.Main/Root/RubberduckInstanceProviderPropertiesInspector.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Castle.Core;
+using Castle.MicroKernel;
+using Castle.MicroKernel.ModelBuilder;
+
+namespace Rubberduck.Root
+{
+    internal class RubberduckInstanceProviderPropertiesInspector : IContributeComponentModelConstruction
+    {
+        public void ProcessModel(IKernel kernel, ComponentModel model)
+        {
+            var targetType = model.Implementation;
+
+            if (!(targetType == typeof(InstanceProvider)))
+            {
+                return;
+            }
+
+            var properties = GetProperties(model, targetType);
+
+            foreach (var property in properties)
+            {
+                model.AddProperty(BuildDependency(property));
+            }
+        }
+
+        private PropertySet BuildDependency(PropertyInfo property)
+        {
+            var dependency = new PropertyDependencyModel(property, isOptional: false);
+            return new PropertySet(property, dependency);
+        }
+
+        private IEnumerable<PropertyInfo> GetProperties(ComponentModel model, Type targetType)
+        {
+            const BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
+            return targetType.GetProperties(bindingFlags).ToList()
+                .Where(property => property.CanWrite
+                                   && property.GetSetMethod(true) != null
+                                   && !property.PropertyType.IsAbstract
+                                   && property.Name.EndsWith("Instance"));
+        }
+    }
+}

Rubberduck.Main/Root/RubberduckIoCInstaller.cs

@@ -189,6 +189,8 @@ public void Install(IWindsorContainer container, IConfigurationStore store)
             RegisterSpecialFactories(container);
             RegisterFactories(container, assembliesToRegister);
 
+            RegisterInstanceProvider(container);
+
             ApplyDefaultInterfaceConvention(container, assembliesToRegister);
         }
 
@@ -288,7 +290,8 @@ private void ApplyDefaultInterfaceConvention(IWindsorContainer container, Assemb
                             && !type.Name.EndsWith("ConfigProvider")
                             && !type.Name.EndsWith("FakesProvider")
                             && !type.GetInterfaces().Contains(typeof(IInspection))
-                            && type.NotDisabledOrExperimental(_initialSettings))
+                            && type.NotDisabledOrExperimental(_initialSettings)
+                            && type != typeof(InstanceProvider))
                     .WithService.DefaultInterfaces()
                     .LifestyleTransient()
                 );
@@ -311,6 +314,20 @@ private void RegisterFactories(IWindsorContainer container, Assembly[] assemblie
             }
         }
 
+        private void RegisterInstanceProvider(IWindsorContainer container)
+        {
+            /*
+            container.Register(Types.FromAssemblyContaining<InstanceProvider>()
+                .IncludeNonPublicTypes()
+                .Where(type => type == typeof(InstanceProvider))
+                .WithServiceSelf()
+                .LifestyleTransient()
+            );*/
+            container.Register(
+                Component.For<InstanceProvider>()
+                    .LifestyleSingleton());
+        }
+
         private void RegisterSourceCodeHandlers(IWindsorContainer container)
         {
             container.Register(Component.For<ISourceCodeHandler>()
@@ -846,7 +863,8 @@ private void OverridePropertyInjection(IWindsorContainer container)
                 .Single();
             container.Kernel.ComponentModelBuilder.RemoveContributor(propInjector);
 
-            container.Kernel.ComponentModelBuilder.AddContributor(new RubberduckPropertiesInspector());
+            container.Kernel.ComponentModelBuilder.AddContributor(new RubberduckViewModelPropertiesInspector());
+            container.Kernel.ComponentModelBuilder.AddContributor(new RubberduckInstanceProviderPropertiesInspector());
         }
 
         private void RegisterParsingEngine(IWindsorContainer container)

…in/Root/RubberduckPropertiesInspector.cs …ubberduckViewModelPropertiesInspector.csRubberduck.Main/Root/RubberduckPropertiesInspector.cs renamed to Rubberduck.Main/Root/RubberduckViewModelPropertiesInspector.cs Rubberduck.Main/Root/RubberduckPropertiesInspector.cs renamed to Rubberduck.Main/Root/RubberduckViewModelPropertiesInspector.cs

@@ -1,21 +1,17 @@
-using Castle.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Castle.Core;
 using Castle.MicroKernel;
 using Castle.MicroKernel.ModelBuilder;
-using Castle.MicroKernel.ModelBuilder.Inspectors;
-using Castle.MicroKernel.SubSystems.Conversion;
 using Rubberduck.UI;
 using Rubberduck.UI.Command;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Rubberduck.Root
 {
     // Loosely based on https://github.com/castleproject/Windsor/blob/36fbebd9a471f88b43044f39704dc5f19e669e6f/src/Castle.Windsor/MicroKernel/ModelBuilder/Inspectors/PropertiesDependenciesModelInspector.cs
-    class RubberduckPropertiesInspector : IContributeComponentModelConstruction
+    internal class RubberduckViewModelPropertiesInspector : IContributeComponentModelConstruction
     {
         public void ProcessModel(IKernel kernel, ComponentModel model)
         {
@@ -27,11 +23,7 @@ public void ProcessModel(IKernel kernel, ComponentModel model)
                 return;
             }
 
-            var properties = GetProperties(model, targetType)
-                .Where(property => property.CanWrite
-                        && property.GetSetMethod() != null
-                        && property.PropertyType.IsBasedOn(typeof(CommandBase))
-                        && !property.PropertyType.IsAbstract);
+            var properties = GetProperties(model, targetType);
 
             foreach (var property in properties)
             {
@@ -45,10 +37,14 @@ private PropertySet BuildDependency(PropertyInfo property)
             return new PropertySet(property, dependency);
         }
 
-        private List<PropertyInfo> GetProperties(ComponentModel model, Type targetType)
+        private IEnumerable<PropertyInfo> GetProperties(ComponentModel model, Type targetType)
         {
-            var bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
-            return targetType.GetProperties(bindingFlags).ToList();
+            const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+            return targetType.GetProperties(bindingFlags).ToList()
+                .Where(property => property.CanWrite
+                                   && property.GetSetMethod() != null
+                                   && property.PropertyType.IsBasedOn(typeof(CommandBase))
+                                   && !property.PropertyType.IsAbstract);
         }
     }
 }