Add entrypoint to analyze request, pipeline, and reports for dependency ordering

global.json

@@ -1,6 +1,6 @@
 {
     "sdk": {
-      "version": "3.1.201",
+      "version": "3.1.301",
       "rollForward": "feature",
       "allowPrerelease": false
     }

src/ApiPort/ApiPort.VisualStudio.Common/Analyze/ApiPortVsAnalyzer.cs

@@ -5,9 +5,11 @@
 using ApiPortVS.Resources;
 using ApiPortVS.ViewModels;
 using Microsoft.Fx.Portability;
+using Microsoft.Fx.Portability.ObjectModel;
 using Microsoft.Fx.Portability.Reporting;
 using Microsoft.Fx.Portability.Reporting.ObjectModel;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -38,6 +40,7 @@ public ApiPortVsAnalyzer(
         }
 
         public async Task<ReportingResult> WriteAnalysisReportsAsync(
+            string entrypoint,
             IEnumerable<string> assemblyPaths,
             IEnumerable<string> installedPackages,
             IFileWriter reportWriter,
@@ -53,7 +56,7 @@ public async Task<ReportingResult> WriteAnalysisReportsAsync(
             var outputFormats = _optionsViewModel.Formats.Where(f => f.IsSelected).Select(f => f.DisplayName);
             var reportFileName = _optionsViewModel.DefaultOutputName;
 
-            var analysisOptions = await GetOptionsAsync(assemblyPaths, outputFormats, installedPackages, Path.Combine(reportDirectory, reportFileName));
+            var analysisOptions = await GetOptionsAsync(entrypoint, assemblyPaths, outputFormats, installedPackages, Path.Combine(reportDirectory, reportFileName));
             var issuesBefore = _reporter.Issues.Count;
 
             var result = await _client.WriteAnalysisReportsAsync(analysisOptions, includeJson);
@@ -73,7 +76,12 @@ public async Task<ReportingResult> WriteAnalysisReportsAsync(
             return result.Result;
         }
 
-        private async Task<IApiPortOptions> GetOptionsAsync(IEnumerable<string> assemblyPaths, IEnumerable<string> formats, IEnumerable<string> referencedNugetPackages, string reportFileName)
+        private async Task<IApiPortOptions> GetOptionsAsync(
+            string entrypoint,
+            IEnumerable<string> assemblyPaths,
+            IEnumerable<string> formats,
+            IEnumerable<string> referencedNugetPackages,
+            string reportFileName)
         {
             await _optionsViewModel.UpdateAsync().ConfigureAwait(false);
             await Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
@@ -98,21 +106,26 @@ private async Task<IApiPortOptions> GetOptionsAsync(IEnumerable<string> assembly
                 _outputWindow.WriteLine(LocalizedStrings.TargetSelectionGuidance);
             }
 
-            // TODO: Allow setting description
-            string description = null;
-
-            // NuGet packages referenced in the project system are not
-            // explicitly passed in, so we'll not want to see their portability
-            // statistics.
-            return new AnalysisOptions(
-                description,
-                assemblyPaths,
-                targets,
-                formats,
-                referencedNugetPackages,
-                !_optionsViewModel.SaveMetadata,
-                reportFileName,
-                isAssemblySpecified: false);
+            var flags = AnalyzeRequestFlags.ShowNonPortableApis;
+
+            if (!_optionsViewModel.SaveMetadata)
+            {
+                flags |= AnalyzeRequestFlags.NoTelemetry;
+            }
+
+            return new ReadWriteApiPortOptions
+            {
+                Entrypoint = entrypoint,
+                OutputFileName = reportFileName,
+                InputAssemblies = assemblyPaths.Select(target => new KeyValuePair<IAssemblyFile, bool>(new AssemblyFile(target), false)).ToImmutableDictionary(),
+                Targets = targets,
+                OutputFormats = formats,
+                RequestFlags = flags,
+                ReferencedNuGetPackages = referencedNugetPackages ?? Enumerable.Empty<string>(),
+                IgnoredAssemblyFiles = Enumerable.Empty<string>(),
+                BreakingChangeSuppressions = Enumerable.Empty<string>(),
+                InvalidInputFiles = Enumerable.Empty<string>(),
+            };
         }
     }
 }

src/ApiPort/ApiPort.VisualStudio.Common/Analyze/FileListAnalyzer.cs

@@ -21,7 +21,7 @@ public FileListAnalyzer(IVsApiPortAnalyzer analyzer, IFileWriter reportWriter)
 
         public async Task AnalyzeProjectAsync(IEnumerable<string> inputAssemblyPaths)
         {
-            await _analyzer.WriteAnalysisReportsAsync(inputAssemblyPaths, Enumerable.Empty<string>(), _reportWriter, false).ConfigureAwait(false);
+            await _analyzer.WriteAnalysisReportsAsync(null, inputAssemblyPaths, Enumerable.Empty<string>(), _reportWriter, false).ConfigureAwait(false);
         }
     }
 }

src/ApiPort/ApiPort.VisualStudio.Common/Analyze/IVsApiPortAnalyzer.cs

@@ -11,6 +11,7 @@ namespace ApiPortVS.Analyze
     public interface IVsApiPortAnalyzer
     {
         Task<ReportingResult> WriteAnalysisReportsAsync(
+            string entrypoint,
             IEnumerable<string> inputAssemblyPaths,
             IEnumerable<string> installedPackages,
             IFileWriter reportWriter,

src/ApiPort/ApiPort.VisualStudio.Common/Analyze/ProjectAnalyzer.cs

@@ -13,6 +13,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -50,7 +51,7 @@ public ProjectAnalyzer(
             _outputWindowWriter = outputWindowWriter;
         }
 
-        public async Task AnalyzeProjectAsync(ICollection<Project> projects, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task AnalyzeProjectAsync(ICollection<Project> projects, Project entryproject, CancellationToken cancellationToken = default(CancellationToken))
         {
             var buildSucceeded = await _builder.BuildAsync(projects).ConfigureAwait(false);
 
@@ -61,6 +62,8 @@ public ProjectAnalyzer(
 
             // TODO: Add option to include everything in output, not just build artifacts
             var targetAssemblies = new ConcurrentBag<string>();
+            var projectName = entryproject?.Name;
+            var entrypoint = default(string);
 
             var referencedNuGetPackages = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             foreach (var project in projects)
@@ -73,9 +76,14 @@ public ProjectAnalyzer(
                     continue;
                 }
 
+                if (string.Equals(projectName, project.Name, StringComparison.OrdinalIgnoreCase))
+                {
+                    entrypoint = output.FirstOrDefault();
+                }
+
                 foreach (var file in output)
                 {
-                    targetAssemblies.Add(file);
+                    targetAssemblies.Add(Path.GetFileName(file));
                 }
 
                 referencedNuGetPackages.UnionWith(GetPackageReferences(project));
@@ -86,7 +94,7 @@ public ProjectAnalyzer(
                 throw new PortabilityAnalyzerException(LocalizedStrings.FailedToLocateBuildOutputDir);
             }
 
-            var result = await _analyzer.WriteAnalysisReportsAsync(targetAssemblies, referencedNuGetPackages, _reportWriter, true).ConfigureAwait(false);
+            var result = await _analyzer.WriteAnalysisReportsAsync(entrypoint, targetAssemblies, referencedNuGetPackages, _reportWriter, true).ConfigureAwait(false);
             var sourceItems = await Task.Run(() => _sourceLineMapper.GetSourceInfo(targetAssemblies, result)).ConfigureAwait(false);
 
             var dictionary = new ConcurrentBag<CalculatedProject>();

src/ApiPort/ApiPort.VisualStudio/AnalyzeMenu.cs

@@ -39,16 +39,16 @@ public async Task AnalyzeSelectedProjectsAsync(bool includeDependencies)
         {
             var projects = GetSelectedProjects();
 
-            await AnalyzeProjectsAsync(includeDependencies ? GetTransitiveReferences(projects, new HashSet<Project>()) : projects).ConfigureAwait(false);
+            await AnalyzeProjectsAsync(includeDependencies ? GetTransitiveReferences(projects, new HashSet<Project>()) : projects, projects.FirstOrDefault()).ConfigureAwait(false);
         }
 
         public async void SolutionContextMenuItemCallback(object sender, EventArgs e)
         {
             await Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
-            await AnalyzeProjectsAsync(_dte.Solution.GetProjects().Where(x => x.IsDotNetProject()).ToList()).ConfigureAwait(false);
+            await AnalyzeProjectsAsync(_dte.Solution.GetProjects().Where(x => x.IsDotNetProject()).ToList(), null).ConfigureAwait(false);
         }
 
-        private async Task AnalyzeProjectsAsync(ICollection<Project> projects)
+        private async Task AnalyzeProjectsAsync(ICollection<Project> projects, Project entrypoint)
         {
             if (!projects.Any())
             {
@@ -63,7 +63,7 @@ private async Task AnalyzeProjectsAsync(ICollection<Project> projects)
                 {
                     var projectAnalyzer = innerScope.Resolve<ProjectAnalyzer>();
 
-                    await projectAnalyzer.AnalyzeProjectAsync(projects).ConfigureAwait(false);
+                    await projectAnalyzer.AnalyzeProjectAsync(projects, entrypoint).ConfigureAwait(false);
                 }
             }
             catch (PortabilityAnalyzerException ex)

src/ApiPort/ApiPort/CommandLineOptions.cs

@@ -22,6 +22,7 @@ public static ICommandLineOptions ParseCommandLineOptions(string[] args)
             IReadOnlyList<string> file = Array.Empty<string>();
             string outFile = DefaultName;
             string description = string.Empty;
+            string entrypoint = string.Empty;
             IReadOnlyList<string> target = Array.Empty<string>();
             IReadOnlyList<string> result = Array.Empty<string>();
             bool showNonPortableApis = true;
@@ -47,6 +48,7 @@ public static ICommandLineOptions ParseCommandLineOptions(string[] args)
                     syntax.DefineOption("o|out", ref outFile, LocalizedStrings.CmdAnalyzeOutputFileName);
                     syntax.DefineOption("d|description", ref description, LocalizedStrings.CmdAnalyzeDescription);
                     syntax.DefineOption("e|endpoint", ref endpoint, LocalizedStrings.CmdEndpoint);
+                    syntax.DefineOption("entrypoint", ref entrypoint, LocalizedStrings.CmdEntrypoint);
                     syntax.DefineOptionList("t|target", ref target, LocalizedStrings.CmdAnalyzeTarget);
                     syntax.DefineOptionList("r|resultFormat", ref result, LocalizedStrings.CmdAnalyzeResultFormat);
                     syntax.DefineOption("p|showNonPortableApis", ref showNonPortableApis, LocalizedStrings.CmdAnalyzeShowNonPortableApis);
@@ -103,6 +105,7 @@ public static ICommandLineOptions ParseCommandLineOptions(string[] args)
             {
                 BreakingChangeSuppressions = suppressBreakingChange,
                 Description = description,
+                Entrypoint = entrypoint,
                 IgnoredAssemblyFiles = ignoreAssemblyFile,
                 InputAssemblies = inputFiles,
                 InvalidInputFiles = invalidFiles,

src/ApiPort/ApiPort/DependencyBuilder.cs

@@ -70,6 +70,10 @@ public static IContainer Build(ICommandLineOptions options, ProductInformation p
                 .As<IEnumerable<IgnoreAssemblyInfo>>()
                 .SingleInstance();
 
+            builder.RegisterType<DependencyOrderer>()
+                .As<IDependencyOrderer>()
+                .SingleInstance();
+
             builder.RegisterType<ReflectionMetadataDependencyFinder>()
                 .As<IDependencyFinder>()
                 .SingleInstance();

src/ApiPort/ApiPort/Resources/LocalizedStrings.resx

@@ -298,4 +298,7 @@ Versions marked with an asterisk (*) implies that these are default targets if n
   <data name="CmdAnalyzeShowExceptionApis" xml:space="preserve">
     <value>Include the Apis that may throw PlatformNotSupported or NotImplemented exceptions</value>
   </data>
+  <data name="CmdEntrypoint" xml:space="preserve">
+    <value>Application that will be run after porting</value>
+  </data>
 </root>

src/lib/Microsoft.Fx.Portability.Reports.Excel/ExcelOpenXmlOutputWriter.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Drawing.Charts;
 using DocumentFormat.OpenXml.Packaging;
 using DocumentFormat.OpenXml.Spreadsheet;
 using Microsoft.Fx.OpenXmlExtensions;
@@ -75,6 +74,11 @@ public async Task WriteToAsync(Stream outputStream)
                         GenerateUnreferencedAssembliesPage(spreadsheet.AddWorksheet(LocalizedStrings.UnresolvedUsedAssembly), _response);
                     }
 
+                    if (_response.RecommendedOrder.Any())
+                    {
+                        GenerateOrderPage(spreadsheet.AddWorksheet(LocalizedStrings.RecommendedOrderHeader), _response);
+                    }
+
                     if (_response.BreakingChanges.Any())
                     {
                         GenerateBreakingChangesPage(spreadsheet.AddWorksheet(LocalizedStrings.BreakingChanges), _response.BreakingChanges);
@@ -226,6 +230,27 @@ private static void GenerateUnreferencedAssembliesPage(Worksheet missingAssembli
             missingAssembliesPage.AddColumnWidth(40, 40, 30);
         }
 
+        private static void GenerateOrderPage(Worksheet page, AnalyzeResponse response)
+        {
+            page.AddRow(new[] { LocalizedStrings.RecommendedOrderDetails });
+            page.AddRow();
+
+            var header = new[] { LocalizedStrings.AssemblyHeader };
+            page.AddRow(header);
+
+            int detailsRows = 1;
+
+            foreach (var assembly in response.RecommendedOrder)
+            {
+                page.AddRow(assembly);
+                detailsRows++;
+            }
+
+            // Generate the pretty table
+            page.AddTable(3, detailsRows, 1, header.ToArray());
+            page.AddColumnWidth(100);
+        }
+
         private void GenerateDetailsPage(Worksheet detailsPage, ReportingResult analysisResult)
         {
             var showAssemblyColumn = analysisResult.GetAssemblyUsageInfo().Any();

src/lib/Microsoft.Fx.Portability.Reports.Excel/Resources/LocalizedStrings.resx

@@ -181,6 +181,12 @@
   <data name="NoExceptionNoted" xml:space="preserve">
     <value>No Notable Exceptions</value>
   </data>
+  <data name="RecommendedOrderDetails" xml:space="preserve">
+    <value>Migration is much easier by following a bottom up approach. Projects with less dependencies should be migrated to .NET Standard or .NET Core first, followed by the ones that may depend on that. For this submission, the following is the recommended order:</value>
+  </data>
+  <data name="RecommendedOrderHeader" xml:space="preserve">
+    <value>Recommended Order</value>
+  </data>
   <data name="SkippedAssembly" xml:space="preserve">
     <value>Skipped Assembly</value>
   </data>