Provide ability to add project references (#1318)

* Provide ability to add project references

This change updates NodejsProjectNode to detect if the UWP project
flavor is active to provide support for project references.
Alternative approach could have been to make NodejsProjectNode public
(so that I could reference it from the UWP project system)
but that would cause a huge changes as opposed to this less
intrusive change.

* Move GetProviderContexts to virtual method

Also moves checks for adding/removing reference providers to
virtual methods as well.

Author: munyirik

Common/Product/SharedProject/ProjectNode.cs

@@ -63,7 +63,8 @@ internal abstract partial class ProjectNode : HierarchyNode,
         IBuildDependencyUpdate,
         IVsProjectSpecialFiles,
         IVsProjectBuildSystem,
-        IOleCommandTarget {
+        IOleCommandTarget,
+        IVsReferenceManagerUser {
         #region nested types
 
 #if DEV14_OR_LATER
@@ -1383,71 +1384,191 @@ public virtual VSADDRESULT RunWizard(HierarchyNode parentNode, string itemName,
         }
 
         /// <summary>
-        /// This overrides the base class method to show the VS 2005 style Add reference dialog. The ProjectNode implementation
-        /// shows the VS 2003 style Add Reference dialog.
+        /// Shows the Add Reference dialog.
         /// </summary>
-        /// <returns>S_OK if succeeded. Failure other wise</returns>
-        public virtual int AddProjectReference() {
-            IVsComponentSelectorDlg2 componentDialog;
-            Guid guidEmpty = Guid.Empty;
-            VSCOMPONENTSELECTORTABINIT[] tabInit = new VSCOMPONENTSELECTORTABINIT[4];
-            string strBrowseLocations = Path.GetDirectoryName(ProjectHome);
+        /// <returns>S_OK if succeeded. Failure otherwise</returns>
+        public int AddProjectReference() {
+            var referenceManager = this.GetService(typeof(SVsReferenceManager)) as IVsReferenceManager;
+            if (referenceManager != null) {
+                var contextGuids = new[] {
+                    VSConstants.ProjectReferenceProvider_Guid,
+                    VSConstants.FileReferenceProvider_Guid
+                };
+                referenceManager.ShowReferenceManager(
+                    this,
+                    SR.GetString(SR.AddReferenceDialogTitle),
+                    "VS.ReferenceManager",
+                    contextGuids.First(),
+                    false);
+                return VSConstants.S_OK;
+            } else {
+                return VSConstants.E_NOINTERFACE;
+            }
+        }
 
-            //Add the Project page
-            tabInit[0].dwSize = (uint)Marshal.SizeOf(typeof(VSCOMPONENTSELECTORTABINIT));
-            // Tell the Add Reference dialog to call hierarchies GetProperty with the following
-            // propID to enable filtering out ourself from the Project to Project reference
-            tabInit[0].varTabInitInfo = (int)__VSHPROPID.VSHPROPID_ShowProjInSolutionPage;
-            tabInit[0].guidTab = VSConstants.GUID_SolutionPage;
+        #region IVsReferenceManagerUser Members
 
-            // Add the Browse for file page            
-            tabInit[1].dwSize = (uint)Marshal.SizeOf(typeof(VSCOMPONENTSELECTORTABINIT));
-            tabInit[1].guidTab = VSConstants.GUID_COMPlusPage;
-            tabInit[1].varTabInitInfo = 0;
+        void IVsReferenceManagerUser.ChangeReferences(uint operation, IVsReferenceProviderContext changedContext) {
+            var op = (__VSREFERENCECHANGEOPERATION)operation;
+            __VSREFERENCECHANGEOPERATIONRESULT result;
 
-            // Add the Browse for file page            
-            tabInit[2].dwSize = (uint)Marshal.SizeOf(typeof(VSCOMPONENTSELECTORTABINIT));
-            tabInit[2].guidTab = VSConstants.GUID_BrowseFilePage;
-            tabInit[2].varTabInitInfo = 0;
+            try {
+                if (op == __VSREFERENCECHANGEOPERATION.VSREFERENCECHANGEOPERATION_ADD) {
+                    result = this.AddReferences(changedContext);
+                } else {
+                    result = this.RemoveReferences(changedContext);
+                }
+            } catch (InvalidOperationException e) {
+                Debug.Fail(e.ToString());
+                result = __VSREFERENCECHANGEOPERATIONRESULT.VSREFERENCECHANGEOPERATIONRESULT_DENY;
+            }
 
-            // Add the WebPI page
-            tabInit[3].dwSize = (uint)Marshal.SizeOf(typeof(VSCOMPONENTSELECTORTABINIT));
-            tabInit[3].guidTab = typeof(WebPiComponentPickerControl).GUID;
-            tabInit[3].varTabInitInfo = 0;
+            if (result == __VSREFERENCECHANGEOPERATIONRESULT.VSREFERENCECHANGEOPERATIONRESULT_DENY) {
+                throw new InvalidOperationException();
+            }
+        }
 
-            uint pX = 0, pY = 0;
+        Array IVsReferenceManagerUser.GetProviderContexts() {
+            return this.GetProviderContexts();
+        }
 
-            componentDialog = GetService(typeof(SVsComponentSelectorDlg)) as IVsComponentSelectorDlg2;
-            try {
-                // call the container to open the add reference dialog.
-                if (componentDialog != null) {
-                    // Let the project know not to show itself in the Add Project Reference Dialog page
-                    ShowProjectInSolutionPage = false;
-
-                    // call the container to open the add reference dialog.
-                    ErrorHandler.ThrowOnFailure(componentDialog.ComponentSelectorDlg2(
-                        (System.UInt32)(__VSCOMPSELFLAGS.VSCOMSEL_MultiSelectMode | __VSCOMPSELFLAGS.VSCOMSEL_IgnoreMachineName),
-                        (IVsComponentUser)this,
-                        0,
-                        null,
-                        SR.GetString(SR.AddReferenceDialogTitle), // Title
-                        "VS.AddReference", // Help topic
-                        ref pX,
-                        ref pY,
-                        (uint)tabInit.Length,
-                        tabInit,
-                        ref guidEmpty,
-                        AddReferenceExtensions.Replace('|', '\0') + "\0",
-                        ref strBrowseLocations));
-                }
-            } catch (COMException e) {
-                Trace.WriteLine("Exception : " + e.Message);
-                return e.ErrorCode;
-            } finally {
-                // Let the project know it can show itself in the Add Project Reference Dialog page
-                ShowProjectInSolutionPage = true;
+        #endregion
+
+        protected virtual Array GetProviderContexts() {
+            var referenceManager = this.GetService(typeof(SVsReferenceManager)) as IVsReferenceManager;
+
+            var contextProviders = new[] {
+                CreateProjectReferenceProviderContext(referenceManager),
+                CreateFileReferenceProviderContext(referenceManager),
+            };
+
+            return contextProviders;
+        }
+
+        private IVsReferenceProviderContext CreateProjectReferenceProviderContext(IVsReferenceManager mgr) {
+            var context = mgr.CreateProviderContext(VSConstants.ProjectReferenceProvider_Guid) as IVsProjectReferenceProviderContext;
+            context.CurrentProject = this;
+
+            var referenceContainer = this.GetReferenceContainer();
+            var references = referenceContainer
+                .EnumReferences()
+                .OfType<ProjectReferenceNode>();
+            foreach (var reference in references) {
+                var newReference = context.CreateReference() as IVsProjectReference;
+                newReference.Identity = reference.ReferencedProjectGuid.ToString("B");
             }
-            return VSConstants.S_OK;
+
+            return context as IVsReferenceProviderContext;
+        }
+
+        private IVsReferenceProviderContext CreateFileReferenceProviderContext(IVsReferenceManager mgr) {
+            var context = mgr.CreateProviderContext(VSConstants.FileReferenceProvider_Guid) as IVsFileReferenceProviderContext;
+
+            context.BrowseFilter = AddReferenceExtensions.Replace('|', '\0') + "\0";
+            return context as IVsReferenceProviderContext;
+        }
+
+        private __VSREFERENCECHANGEOPERATIONRESULT AddReferences(IVsReferenceProviderContext context) {
+            var addedReferences = this.GetAddedReferences(context);
+
+            var referenceContainer = this.GetReferenceContainer();
+            foreach (var selectorData in addedReferences) {
+                referenceContainer.AddReferenceFromSelectorData(selectorData);
+            }
+
+            return __VSREFERENCECHANGEOPERATIONRESULT.VSREFERENCECHANGEOPERATIONRESULT_ALLOW;
+        }
+
+        protected virtual IEnumerable<VSCOMPONENTSELECTORDATA> GetAddedReferences(IVsReferenceProviderContext context) {
+            var addedReferences = Enumerable.Empty<VSCOMPONENTSELECTORDATA>();
+
+            if (context.ProviderGuid == VSConstants.ProjectReferenceProvider_Guid) {
+                addedReferences = GetAddedReferences(context as IVsProjectReferenceProviderContext);
+            }
+            else if (context.ProviderGuid == VSConstants.FileReferenceProvider_Guid) {
+                addedReferences = GetAddedReferences(context as IVsFileReferenceProviderContext);
+            }
+
+            return addedReferences;
+        }
+
+        private __VSREFERENCECHANGEOPERATIONRESULT RemoveReferences(IVsReferenceProviderContext context) {
+            var removedReferences = this.GetRemovedReferences(context);
+
+            foreach (var refNode in removedReferences) {
+                refNode.Remove(true /* delete from storage*/);
+            }
+
+            return __VSREFERENCECHANGEOPERATIONRESULT.VSREFERENCECHANGEOPERATIONRESULT_ALLOW;
+        }
+
+        protected virtual IEnumerable<ReferenceNode> GetRemovedReferences(IVsReferenceProviderContext context) {
+            var removedReferences = Enumerable.Empty<ReferenceNode>();
+
+            if (context.ProviderGuid == VSConstants.ProjectReferenceProvider_Guid) {
+                removedReferences = GetRemovedReferences(context as IVsProjectReferenceProviderContext);
+            }
+            else if (context.ProviderGuid == VSConstants.FileReferenceProvider_Guid) {
+                removedReferences = GetRemovedReferences(context as IVsFileReferenceProviderContext);
+            }
+
+            return removedReferences;
+        }
+
+        private IEnumerable<VSCOMPONENTSELECTORDATA> GetAddedReferences(IVsProjectReferenceProviderContext context) {
+            var selectedReferences = context
+                .References
+                .OfType<IVsProjectReference>()
+                .Select(reference => new VSCOMPONENTSELECTORDATA() {
+                    type = VSCOMPONENTTYPE.VSCOMPONENTTYPE_Project,
+                    bstrTitle = reference.Name,
+                    bstrFile = new FileInfo(reference.FullPath).Directory.FullName,
+                    bstrProjRef = reference.ReferenceSpecification,
+                });
+
+            return selectedReferences;
+        }
+
+        private IEnumerable<ReferenceNode> GetRemovedReferences(IVsProjectReferenceProviderContext context) {
+            var selectedReferences = context
+                .References
+                .OfType<IVsProjectReference>()
+                .Select(asmRef => new Guid(asmRef.Identity));
+
+            var referenceContainer = this.GetReferenceContainer();
+            var references = referenceContainer
+                .EnumReferences()
+                .OfType<ProjectReferenceNode>()
+                .Where(refNode => selectedReferences.Contains(refNode.ReferencedProjectGuid));
+
+            return references;
+        }
+
+        private IEnumerable<VSCOMPONENTSELECTORDATA> GetAddedReferences(IVsFileReferenceProviderContext context) {
+            var selectedReferences = context
+                .References
+                .OfType<IVsFileReference>()
+                .Select(reference => new VSCOMPONENTSELECTORDATA() {
+                    type = VSCOMPONENTTYPE.VSCOMPONENTTYPE_File,
+                    bstrFile = reference.FullPath,
+                 });
+
+            return selectedReferences;
+        }
+
+        private IEnumerable<ReferenceNode> GetRemovedReferences(IVsFileReferenceProviderContext context) {
+            var selectedReferences = context
+                .References
+                .OfType<IVsFileReference>()
+                .Select(fileRef => fileRef.FullPath);
+
+            var referenceContainer = this.GetReferenceContainer();
+            var references = referenceContainer
+                .EnumReferences()
+                .OfType<ReferenceNode>()
+                .Where(refNode => selectedReferences.Contains(refNode.Url));
+
+            return references;
         }
 
         protected virtual string AddReferenceExtensions {

Common/Product/SharedProject/ProjectResources.resx

@@ -609,7 +609,7 @@ Run Visual Studio with the /Log option and check ActivityLog.xml for more detail
 {0}</value>
   </data>
   <data name="AddReferenceExtensions" xml:space="preserve">
-    <value>Dynamic Link Libraries (*.dll)|*.dll|All Files (*.*)|*.*</value>
+    <value>Component Files|*.winmd</value>
   </data>
   <data name="WebPiFeedError" xml:space="preserve">
     <value>Unable to get feed "{0}".

Nodejs/Product/Nodejs/Guids.cs

@@ -74,5 +74,8 @@ static class Guids {
 
         public const string OfficeToolsBootstrapperCmdSetString = "{D26C976C-8EE8-4EC4-8746-F5F7702A17C5}";
         public static readonly Guid OfficeToolsBootstrapperCmdSet = new Guid(OfficeToolsBootstrapperCmdSetString);
+		
+        // UWP project flavor guid
+        public const string NodejsUwpProjectFlavor = "00251F00-BA30-4CE4-96A2-B8A1085F37AA";
     };
 }

Nodejs/Product/Nodejs/Project/NodejsProjectNode.cs

@@ -614,7 +614,19 @@ internal override object Object {
         }
 
         protected override ReferenceContainerNode CreateReferenceContainerNode() {
-            return null;
+            // Only create a reference node if the project is targeting UWP
+            if(GetProjectTypeGuids().Contains(Guids.NodejsUwpProjectFlavor)) {
+                return base.CreateReferenceContainerNode();
+            } else {
+                return null;
+            }
+        }
+
+        private string GetProjectTypeGuids()
+        {
+            string projectTypeGuids = "";
+            ErrorHandler.ThrowOnFailure(((IVsAggregatableProject)this).GetAggregateProjectTypeGuids(out projectTypeGuids));
+            return projectTypeGuids;
         }
 
         public NodeModulesNode ModulesNode { get; private set; }