Made some changes to how DTH sees wrapped projects

src/Microsoft.Framework.DesignTimeHost/ApplicationContext.cs

@@ -887,12 +887,17 @@ private DependencyInfo ResolveProjectDepencies(Project project, string configura
                     RawReferences = new Dictionary<string, byte[]>()
                 };
 
-                // Watch all projects for project.json changes
                 foreach (var library in applicationHostContext.DependencyWalker.Libraries)
                 {
                     var description = CreateDependencyDescription(library);
                     info.Dependencies[description.Name] = description;
 
+                    // Skip unresolved libraries
+                    if (!library.Resolved)
+                    {
+                        continue;
+                    }
+
                     if (string.Equals(library.Type, "Project") &&
                        !string.Equals(library.Identity.Name, project.Name))
                     {
@@ -909,15 +914,19 @@ private DependencyInfo ResolveProjectDepencies(Project project, string configura
                         if (!string.IsNullOrEmpty(targetFrameworkInformation.AssemblyPath) &&
                             string.IsNullOrEmpty(targetFrameworkInformation.WrappedProject))
                         {
-                            info.References.Add(GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.AssemblyPath));
+                            string assemblyPath = GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.AssemblyPath);
+                            info.References.Add(assemblyPath);
+
+                            description.Path = assemblyPath;
+                            description.Type = "Assembly";
                         }
                         else
                         {
-                            string projectPath = library.Path;
+                            string wrappedProjectPath = null;
 
                             if (!string.IsNullOrEmpty(targetFrameworkInformation.WrappedProject))
                             {
-                                projectPath = GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.WrappedProject);
+                                wrappedProjectPath = GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.WrappedProject);
                             }
 
                             info.ProjectReferences.Add(new ProjectReference
@@ -928,7 +937,8 @@ private DependencyInfo ResolveProjectDepencies(Project project, string configura
                                     FrameworkName = library.Framework.ToString(),
                                     FriendlyName = frameworkResolver.GetFriendlyFrameworkName(library.Framework)
                                 },
-                                Path = projectPath
+                                Path = library.Path,
+                                WrappedProjectPath = wrappedProjectPath
                             });
                         }
                     }
@@ -976,7 +986,7 @@ private static DependencyDescription CreateDependencyDescription(LibraryDescript
             {
                 Name = library.Identity.Name,
                 Version = library.Identity.Version == null ? null : library.Identity.Version.ToString(),
-                Type = library.Type ?? "Unresolved",
+                Type = library.Resolved ? library.Type : "Unresolved",
                 Path = library.Path,
                 Dependencies = library.Dependencies.Select(lib => new DependencyItem
                 {

src/Microsoft.Framework.DesignTimeHost/Models/OutgoingMessages/ProjectReference.cs

@@ -6,13 +6,15 @@ public class ProjectReference
     {
         public FrameworkData Framework { get; set; }
         public string Path { get; set; }
+        public string WrappedProjectPath { get; set; }
 
         public override bool Equals(object obj)
         {
             var other = obj as ProjectReference;
             return other != null &&
-                   string.Equals(Framework, other.Framework) &&
-                   object.Equals(Path, other.Path);
+                   object.Equals(Framework, other.Framework) &&
+                   string.Equals(Path, other.Path) &&
+                   string.Equals(WrappedProjectPath, other.WrappedProjectPath);
         }
 
         public override int GetHashCode()

src/Microsoft.Framework.PackageManager/Packing/DependencyContext.cs

@@ -28,7 +28,6 @@ public DependencyContext(string projectDirectory, string configuration, Framewor
             ProjectResolver = applicationHostContext.ProjectResolver;
             NuGetDependencyResolver = applicationHostContext.NuGetDependencyProvider;
             ProjectReferenceDependencyProvider = applicationHostContext.ProjectDepencyProvider;
-            UnresolvedDependencyProvider = applicationHostContext.UnresolvedDependencyProvider;
             DependencyWalker = applicationHostContext.DependencyWalker;
             FrameworkName = targetFramework;
             PackagesDirectory = applicationHostContext.PackagesDirectory;
@@ -37,7 +36,6 @@ public DependencyContext(string projectDirectory, string configuration, Framewor
         public IProjectResolver ProjectResolver { get; set; }
         public NuGetDependencyResolver NuGetDependencyResolver { get; set; }
         public ProjectReferenceDependencyProvider ProjectReferenceDependencyProvider { get; set; }
-        public UnresolvedDependencyProvider UnresolvedDependencyProvider { get; set; }
         public DependencyWalker DependencyWalker { get; set; }
         public FrameworkName FrameworkName { get; set; }
         public ILookup<string, PackageAssembly> PackageAssemblies { get; set; }

src/Microsoft.Framework.PackageManager/Packing/PackManager.cs

@@ -183,11 +183,11 @@ public bool Package()
             foreach (var dependencyContext in frameworkContexts.Values)
             {
                 // If there's any unresolved dependencies then complain and keep working
-                if (dependencyContext.UnresolvedDependencyProvider.UnresolvedDependencies.Any())
+                if (dependencyContext.DependencyWalker.Libraries.Any(l => !l.Resolved))
                 {
                     anyUnresolvedDependency = true;
                     var message = "Warning: " +
-                        dependencyContext.UnresolvedDependencyProvider.GetMissingDependenciesWarning(
+                        dependencyContext.DependencyWalker.GetMissingDependenciesWarning(
                             dependencyContext.FrameworkName);
                     _options.Reports.Quiet.WriteLine(message.Yellow());
                 }

src/Microsoft.Framework.Runtime/ApplicationHostContext.cs

@@ -36,18 +36,16 @@ public ApplicationHostContext(IServiceProvider serviceProvider,
             NuGetDependencyProvider = new NuGetDependencyResolver(PackagesDirectory, RootDirectory);
             var gacDependencyResolver = new GacDependencyResolver();
             ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
-            UnresolvedDependencyProvider = new UnresolvedDependencyProvider();
+            var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
 
             DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
                 ProjectDepencyProvider,
                 NuGetDependencyProvider,
                 referenceAssemblyDependencyResolver,
                 gacDependencyResolver,
-                UnresolvedDependencyProvider
+                unresolvedDependencyProvider
             });
 
-            UnresolvedDependencyProvider.AttemptedProviders = DependencyWalker.DependencyProviders;
-
             LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
                 new ProjectLibraryExportProvider(ProjectResolver, ServiceProvider),
                 referenceAssemblyDependencyResolver,
@@ -113,8 +111,6 @@ public Project Project
 
         public IAssemblyLoadContextFactory AssemblyLoadContextFactory { get; private set; }
 
-        public UnresolvedDependencyProvider UnresolvedDependencyProvider { get; private set; }
-
         public NuGetDependencyResolver NuGetDependencyProvider { get; private set; }
 
         public ProjectReferenceDependencyProvider ProjectDepencyProvider { get; private set; }

src/Microsoft.Framework.Runtime/DefaultHost.cs

@@ -60,9 +60,9 @@ public Assembly GetEntryPoint(string applicationName)
             Initialize();
 
             // If there's any unresolved dependencies then complain
-            if (_applicationHostContext.UnresolvedDependencyProvider.UnresolvedDependencies.Any())
+            if (_applicationHostContext.DependencyWalker.Libraries.Any(l => !l.Resolved))
             {
-                var exceptionMsg = _applicationHostContext.UnresolvedDependencyProvider.GetMissingDependenciesWarning(
+                var exceptionMsg = _applicationHostContext.DependencyWalker.GetMissingDependenciesWarning(
                     _targetFramework);
                 throw new InvalidOperationException(exceptionMsg);
             }

src/Microsoft.Framework.Runtime/DependencyManagement/DependencyWalker.cs

@@ -3,7 +3,9 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Runtime.Versioning;
+using System.Text;
 using NuGet;
 
 namespace Microsoft.Framework.Runtime
@@ -49,5 +51,38 @@ public void Walk(string name, SemanticVersion version, FrameworkName targetFrame
             sw.Stop();
             Trace.TraceInformation("[{0}]: Resolved dependencies for {1} in {2}ms", GetType().Name, name, sw.ElapsedMilliseconds);
         }
+
+        public string GetMissingDependenciesWarning(FrameworkName targetFramework)
+        {
+            var sb = new StringBuilder();
+
+            // TODO: Localize messages
+
+            sb.AppendFormat("Failed to resolve the following dependencies for target framework '{0}':", targetFramework.ToString());
+            sb.AppendLine();
+
+            foreach (var d in Libraries.Where(d => !d.Resolved).OrderBy(d => d.Identity.Name))
+            {
+                sb.AppendLine("   " + d.Identity.ToString());
+            }
+
+            sb.AppendLine();
+            sb.AppendLine("Searched Locations:");
+
+            foreach (var path in GetAttemptedPaths(targetFramework))
+            {
+                sb.AppendLine("  " + path);
+            }
+
+            sb.AppendLine();
+            sb.AppendLine("Try running 'kpm restore'.");
+
+            return sb.ToString();
+        }
+
+        private IEnumerable<string> GetAttemptedPaths(FrameworkName targetFramework)
+        {
+            return DependencyProviders.SelectMany(p => p.GetAttemptedPaths(targetFramework));
+        }
     }
 }

src/Microsoft.Framework.Runtime/DependencyManagement/LibraryDescription.cs

@@ -14,5 +14,6 @@ public class LibraryDescription
         public FrameworkName Framework { get; set; }
         public IEnumerable<LibraryDependency> Dependencies { get; set; }
         public IEnumerable<string> LoadableAssemblies { get; set; }
+        public bool Resolved { get; set; } = true;
     }
 }

src/Microsoft.Framework.Runtime/DependencyManagement/ProjectReferenceDependencyProvider.cs

@@ -87,7 +87,8 @@ public LibraryDescription GetDescription(Library library, FrameworkName targetFr
                 Path = project.ProjectFilePath,
                 Framework = targetFrameworkInfo.FrameworkName,
                 Dependencies = dependencies,
-                LoadableAssemblies = loadableAssemblies
+                LoadableAssemblies = loadableAssemblies,
+                Resolved = targetFrameworkInfo.FrameworkName != null
             };
         }
 

src/Microsoft.Framework.Runtime/DependencyManagement/UnresolvedDependencyProvider.cs

@@ -1,72 +1,31 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.Versioning;
-using System.Text;
-using NuGet;
 
 namespace Microsoft.Framework.Runtime
 {
     public class UnresolvedDependencyProvider : IDependencyProvider
     {
-        public IEnumerable<LibraryDescription> UnresolvedDependencies { get; private set; }
-
-        public IEnumerable<IDependencyProvider> AttemptedProviders { get; set; }
-
-        public UnresolvedDependencyProvider()
-        {
-            UnresolvedDependencies = Enumerable.Empty<LibraryDescription>();
-        }
-
         public LibraryDescription GetDescription(Library library, FrameworkName targetFramework)
         {
             return new LibraryDescription
             {
                 Identity = library,
-                Dependencies = Enumerable.Empty<LibraryDependency>()
+                Dependencies = Enumerable.Empty<LibraryDependency>(),
+                Resolved = false
             };
         }
 
         public void Initialize(IEnumerable<LibraryDescription> dependencies, FrameworkName targetFramework)
         {
-            UnresolvedDependencies = dependencies;
         }
 
         public IEnumerable<string> GetAttemptedPaths(FrameworkName targetFramework)
         {
-            return AttemptedProviders.Where(p => p != this)
-                                     .SelectMany(p => p.GetAttemptedPaths(targetFramework));
-        }
-
-        public string GetMissingDependenciesWarning(FrameworkName targetFramework)
-        {
-            var sb = new StringBuilder();
-
-            // TODO: Localize messages
-
-            sb.AppendFormat("Failed to resolve the following dependencies for target framework '{0}':", targetFramework.ToString());
-            sb.AppendLine();
-
-            foreach (var d in UnresolvedDependencies.OrderBy(d => d.Identity.Name))
-            {
-                sb.AppendLine("   " + d.Identity.ToString());
-            }
-
-            sb.AppendLine();
-            sb.AppendLine("Searched Locations:");
-
-            foreach (var path in GetAttemptedPaths(targetFramework))
-            {
-                sb.AppendLine("  " + path);
-            }
-
-            sb.AppendLine();
-            sb.AppendLine("Try running 'kpm restore'.");
-
-            return sb.ToString();
+            return Enumerable.Empty<string>();
         }
     }
 }

src/Microsoft.Framework.Runtime/DependencyManagement/WalkContext.cs

@@ -289,7 +289,8 @@ public void Populate(FrameworkName frameworkName, IList<LibraryDescription> libr
                         Type = entry.Value.Description.Type,
                         Framework = entry.Value.Description.Framework ?? frameworkName,
                         Dependencies = entry.Value.Dependencies.SelectMany(CorrectDependencyVersion).ToList(),
-                        LoadableAssemblies = entry.Value.Description.LoadableAssemblies ?? Enumerable.Empty<string>()
+                        LoadableAssemblies = entry.Value.Description.LoadableAssemblies ?? Enumerable.Empty<string>(),
+                        Resolved = entry.Value.Description.Resolved
                     };
                 }).ToList();