Added frameworkAssemblies support

- The frameworkAssemblies section is specific to a target framework
- Refactored BuildContext to call into the ProjectReferenceDependencyProvider.
This means that only a single place actually uses the project class directly
(which is nice).
- GetLibraryDescription now takes a Library instead of name and version
(we may need to revisit this and create a different poco). When @lodejard finishes
dependency types we'll see how this ends up
- Preserve the backwards compatibility of declaring frameworkAssemblies in
dependencies temporarily
- Added tests for parsing frameworkAssemblies

#640
#619

src/Microsoft.Framework.PackageManager/Building/BuildContext.cs

@@ -65,66 +65,59 @@ public void PopulateDependencies(PackageBuilder packageBuilder)
                                                                 .Dependencies
                                                                 .ToDictionary(r => r.Identity.Name);
 
-            var frameworkAssemblies = new List<string>();
-
-            var targetFrameworkInformation = _project.GetTargetFramework(_targetFramework);
+            LibraryDescription description;
+            if (!projectReferenceByName.TryGetValue(_project.Name, out description))
+            {
+                return;
+            }
 
-            var targetFramework = targetFrameworkInformation.FrameworkName ?? _targetFramework;
+            foreach (var dependency in description.Dependencies)
+            {
+                if (dependency.IsImplicit)
+                {
+                    continue;
+                }
 
-            var projectDependencies = _project.Dependencies.Concat(targetFrameworkInformation.Dependencies)
-                                                           .ToList();
+                Runtime.Project dependencyProject;
+                if (projectReferenceByName.ContainsKey(dependency.Name) &&
+                    _applicationHostContext.ProjectResolver.TryResolveProject(dependency.Name, out dependencyProject) &&
+                    dependencyProject.EmbedInteropTypes)
+                {
+                    continue;
+                }
 
-            if (projectDependencies.Count > 0)
-            {
-                foreach (var dependency in projectDependencies.OrderBy(d => d.Name))
+                if (dependency.IsGacOrFrameworkReference)
                 {
-                    Runtime.Project dependencyProject;
-                    if (projectReferenceByName.ContainsKey(dependency.Name) &&
-                        _applicationHostContext.ProjectResolver.TryResolveProject(dependency.Name, out dependencyProject) &&
-                        dependencyProject.EmbedInteropTypes)
+                    packageBuilder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.Name, new[] { _targetFramework }));
+                }
+                else
+                {
+                    var dependencyVersion = new VersionSpec()
                     {
-                        continue;
-                    }
+                        IsMinInclusive = true,
+                        MinVersion = dependency.Version
+                    };
 
-                    string path;
-                    if (_applicationHostContext.FrameworkReferenceResolver.TryGetAssembly(dependency.Name, targetFramework, out path))
-                    {
-                        frameworkAssemblies.Add(dependency.Name);
-                    }
-                    else
+                    if (dependencyVersion.MinVersion == null || dependencyVersion.MinVersion.IsSnapshot)
                     {
-                        var dependencyVersion = new VersionSpec()
-                        {
-                            IsMinInclusive = true,
-                            MinVersion = dependency.Version
-                        };
+                        var actual = _applicationHostContext.DependencyWalker.Libraries
+                            .Where(pkg => string.Equals(pkg.Identity.Name, _project.Name, StringComparison.OrdinalIgnoreCase))
+                            .SelectMany(pkg => pkg.Dependencies)
+                            .SingleOrDefault(dep => string.Equals(dep.Name, dependency.Name, StringComparison.OrdinalIgnoreCase));
 
-                        if (dependencyVersion.MinVersion == null || dependencyVersion.MinVersion.IsSnapshot)
+                        if (actual != null)
                         {
-                            var actual = _applicationHostContext.DependencyWalker.Libraries
-                                .Where(pkg => string.Equals(pkg.Identity.Name, _project.Name, StringComparison.OrdinalIgnoreCase))
-                                .SelectMany(pkg => pkg.Dependencies)
-                                .SingleOrDefault(dep => string.Equals(dep.Name, dependency.Name, StringComparison.OrdinalIgnoreCase));
-
-                            if (actual != null)
-                            {
-                                dependencyVersion.MinVersion = actual.Version;
-                            }
+                            dependencyVersion.MinVersion = actual.Version;
                         }
-
-                        dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion));
                     }
-                }
 
-                if (dependencies.Count > 0)
-                {
-                    packageBuilder.DependencySets.Add(new PackageDependencySet(targetFramework, dependencies));
+                    dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion));
                 }
             }
 
-            foreach (var a in frameworkAssemblies)
+            if (dependencies.Count > 0)
             {
-                packageBuilder.FrameworkReferences.Add(new FrameworkAssemblyReference(a, new[] { targetFramework }));
+                packageBuilder.DependencySets.Add(new PackageDependencySet(_targetFramework, dependencies));
             }
         }
 

src/Microsoft.Framework.PackageManager/Restore/LocalWalkProvider.cs

@@ -41,7 +41,13 @@ public LocalWalkProvider(IDependencyProvider dependencyProvider)
 
         public Task<WalkProviderMatch> FindLibraryByName(string name, FrameworkName targetFramework)
         {
-            var description = _dependencyProvider.GetDescription(name, new SemanticVersion(new Version(0, 0)), targetFramework);
+            var library = new Library
+            {
+                Name = name,
+                Version = new SemanticVersion(new Version(0, 0))
+            };
+
+            var description = _dependencyProvider.GetDescription(library, targetFramework);
             if (description == null)
             {
                 return Task.FromResult<WalkProviderMatch>(null);
@@ -56,7 +62,7 @@ public Task<WalkProviderMatch> FindLibraryByName(string name, FrameworkName targ
 
         public Task<WalkProviderMatch> FindLibraryByVersion(Library library, FrameworkName targetFramework)
         {
-            var description = _dependencyProvider.GetDescription(library.Name, library.Version, targetFramework);
+            var description = _dependencyProvider.GetDescription(library, targetFramework);
             if (description == null)
             {
                 return Task.FromResult<WalkProviderMatch>(null);
@@ -71,7 +77,7 @@ public Task<WalkProviderMatch> FindLibraryByVersion(Library library, FrameworkNa
 
         public Task<WalkProviderMatch> FindLibraryBySnapshot(Library library, FrameworkName targetFramework)
         {
-            var description = _dependencyProvider.GetDescription(library.Name, library.Version, targetFramework);
+            var description = _dependencyProvider.GetDescription(library, targetFramework);
             if (description == null)
             {
                 return Task.FromResult<WalkProviderMatch>(null);
@@ -86,7 +92,7 @@ public Task<WalkProviderMatch> FindLibraryBySnapshot(Library library, FrameworkN
 
         public Task<IEnumerable<Library>> GetDependencies(WalkProviderMatch match, FrameworkName targetFramework)
         {
-            var description = _dependencyProvider.GetDescription(match.Library.Name, match.Library.Version, targetFramework);
+            var description = _dependencyProvider.GetDescription(match.Library, targetFramework);
             return Task.FromResult(description.Dependencies);
         }
 

src/Microsoft.Framework.PackageManager/Restore/RestoreCommand.cs

@@ -169,7 +169,8 @@ private async Task<bool> RestoreForProject(string projectJsonPath, string rootDi
                     new ProjectReferenceDependencyProvider(
                         new ProjectResolver(
                             projectDirectory,
-                            rootDirectory))));
+                            rootDirectory),
+                        new EmptyFrameworkResolver())));
 
             localProviders.Add(
                 new LocalWalkProvider(

src/Microsoft.Framework.PackageManager/Restore/RestoreOperations.cs

@@ -130,6 +130,11 @@ public async Task<WalkProviderMatch> FindLibraryMatch(RestoreContext context, Li
                 return null;
             }
 
+            if (library.IsGacOrFrameworkReference)
+            {
+                return null;
+            }
+
             if (library.Version.IsSnapshot)
             {
                 var remoteMatch = await FindLibraryBySnapshot(context, library, context.RemoteLibraryProviders);

src/Microsoft.Framework.Runtime/ApplicationHostContext.cs

@@ -31,14 +31,14 @@ public ApplicationHostContext(IServiceProvider serviceProvider,
             var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
             NuGetDependencyProvider = new NuGetDependencyResolver(PackagesDirectory, FrameworkReferenceResolver);
             var gacDependencyResolver = new GacDependencyResolver();
-            ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
+            ProjectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver, FrameworkReferenceResolver);
             UnresolvedDependencyProvider = new UnresolvedDependencyProvider();
 
             DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
                 ProjectDepencyProvider,
+                NuGetDependencyProvider,
                 referenceAssemblyDependencyResolver,
                 gacDependencyResolver,
-                NuGetDependencyProvider,
                 UnresolvedDependencyProvider
             });
 

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

@@ -30,8 +30,13 @@ public IEnumerable<string> GetAttemptedPaths(FrameworkName targetFramework)
             return GetGacSearchPaths().Select(p => Path.Combine(p, "{name}", "{version}", "{name}.dll"));
         }
 
-        public LibraryDescription GetDescription(string name, SemanticVersion version, FrameworkName targetFramework)
+        public LibraryDescription GetDescription(Library library, FrameworkName targetFramework)
         {
+            if (!library.IsGacOrFrameworkReference)
+            {
+                return null;
+            }
+
             if (PlatformHelper.IsMono)
             {
                 return null;
@@ -42,6 +47,9 @@ public LibraryDescription GetDescription(string name, SemanticVersion version, F
                 return null;
             }
 
+            var name = library.Name;
+            var version = library.Version;
+
             string path;
             if (!TryResolvePartialName(name, out path))
             {
@@ -56,7 +64,13 @@ public LibraryDescription GetDescription(string name, SemanticVersion version, F
 
                 return new LibraryDescription
                 {
-                    Identity = new Library { Name = name, Version = assemblyVersion },
+                    Identity = new Library
+                    {
+                        Name = name,
+                        Version = assemblyVersion,
+                        IsGacOrFrameworkReference = true,
+                        IsImplicit = library.IsImplicit
+                    },
                     Dependencies = Enumerable.Empty<Library>()
                 };
             }

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

@@ -9,7 +9,7 @@ namespace Microsoft.Framework.Runtime
 {
     public interface IDependencyProvider
     {
-        LibraryDescription GetDescription(string name, SemanticVersion version, FrameworkName targetFramework);
+        LibraryDescription GetDescription(Library library, FrameworkName targetFramework);
 
         void Initialize(IEnumerable<LibraryDescription> dependencies, FrameworkName targetFramework);
 

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

@@ -13,6 +13,10 @@ public class Library : IEquatable<Library>
 
         public SemanticVersion Version { get; set; }
 
+        public bool IsGacOrFrameworkReference { get; set; }
+
+        public bool IsImplicit { get; set; }
+
         public override string ToString()
         {
             return Name + " " + Version + (Version != null && Version.IsSnapshot ? "-*" : string.Empty);

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

@@ -50,15 +50,28 @@ public IEnumerable<string> GetAttemptedPaths(FrameworkName targetFramework)
             };
         }
 
-        public LibraryDescription GetDescription(string name, SemanticVersion version, FrameworkName targetFramework)
+        public LibraryDescription GetDescription(Library library, FrameworkName targetFramework)
         {
+            if (library.IsGacOrFrameworkReference)
+            {
+                return null;
+            }
+
+            var name = library.Name;
+            var version = library.Version;
+
             var package = FindCandidate(name, version);
 
             if (package != null)
             {
                 return new LibraryDescription
                 {
-                    Identity = new Library { Name = package.Id, Version = package.Version },
+                    Identity = new Library
+                    {
+                        Name = package.Id,
+                        Version = package.Version,
+                        IsImplicit = library.IsImplicit
+                    },
                     Dependencies = GetDependencies(package, targetFramework)
                 };
             }
@@ -104,7 +117,8 @@ private IEnumerable<Library> GetDependencies(IPackage package, FrameworkName tar
 
                     yield return new Library
                     {
-                        Name = assemblyReference.AssemblyName
+                        Name = assemblyReference.AssemblyName,
+                        IsGacOrFrameworkReference = true
                     };
                 }
             }

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

@@ -13,10 +13,12 @@ namespace Microsoft.Framework.Runtime
     public class ProjectReferenceDependencyProvider : IDependencyProvider
     {
         private readonly IProjectResolver _projectResolver;
+        private readonly IFrameworkReferenceResolver _frameworkReferenceResolver;
 
-        public ProjectReferenceDependencyProvider(IProjectResolver projectResolver)
+        public ProjectReferenceDependencyProvider(IProjectResolver projectResolver, IFrameworkReferenceResolver frameworkReferenceResolver)
         {
             _projectResolver = projectResolver;
+            _frameworkReferenceResolver = frameworkReferenceResolver;
             Dependencies = Enumerable.Empty<LibraryDescription>();
         }
 
@@ -27,8 +29,16 @@ public IEnumerable<string> GetAttemptedPaths(FrameworkName targetFramework)
             return _projectResolver.SearchPaths.Select(p => Path.Combine(p, "{name}", "project.json"));
         }
 
-        public LibraryDescription GetDescription(string name, SemanticVersion version, FrameworkName targetFramework)
+        public LibraryDescription GetDescription(Library library, FrameworkName targetFramework)
         {
+            if (library.IsGacOrFrameworkReference)
+            {
+                return null;
+            }
+
+            var name = library.Name;
+            var version = library.Version;
+
             Project project;
 
             // Can't find a project file with the name so bail
@@ -42,19 +52,54 @@ public LibraryDescription GetDescription(string name, SemanticVersion version, F
 
             if (VersionUtility.IsDesktop(targetFramework))
             {
-                // mscorlib is ok
-                targetFrameworkDependencies.Add(new Library { Name = "mscorlib" });
+                targetFrameworkDependencies.Add(new Library
+                {
+                    Name = "mscorlib",
+                    IsGacOrFrameworkReference = true,
+                    IsImplicit = true
+                });
+
+                targetFrameworkDependencies.Add(new Library
+                {
+                    Name = "System",
+                    IsGacOrFrameworkReference = true,
+                    IsImplicit = true
+                });
 
-                // TODO: Remove these references (but we need to update the dependent projects first)
-                targetFrameworkDependencies.Add(new Library { Name = "System" });
-                targetFrameworkDependencies.Add(new Library { Name = "System.Core" });
-                targetFrameworkDependencies.Add(new Library { Name = "Microsoft.CSharp" });
+                targetFrameworkDependencies.Add(new Library
+                {
+                    Name = "System.Core",
+                    IsGacOrFrameworkReference = true,
+                    IsImplicit = true
+                });
+
+                targetFrameworkDependencies.Add(new Library
+                {
+                    Name = "Microsoft.CSharp",
+                    IsGacOrFrameworkReference = true,
+                    IsImplicit = true
+                });
+            }
+
+            var dependencies = project.Dependencies.Concat(targetFrameworkDependencies).ToList();
+
+            // TODO: Remove this code once there's a new build of the KRE
+            // We need to keep this for bootstrapping to continue working
+            foreach (var d in dependencies)
+            {
+                d.IsGacOrFrameworkReference = d.Version == null &&
+                    _frameworkReferenceResolver.TryGetAssembly(d.Name, targetFramework, out var path);
             }
 
             return new LibraryDescription
             {
-                Identity = new Library { Name = project.Name, Version = project.Version },
-                Dependencies = project.Dependencies.Concat(targetFrameworkDependencies),
+                Identity = new Library
+                {
+                    Name = project.Name,
+                    Version = project.Version,
+                    IsImplicit = library.IsImplicit
+                },
+                Dependencies = dependencies,
             };
         }