feat: align project analysis between project and solution modes + imp. logging of analysis results

Author: dupdob

src/Stryker.Core/Stryker.Core/Initialisation/Buildalyzer/IAnalyzerResultExtensions.cs

@@ -125,7 +125,12 @@ internal static NuGetFramework GetNuGetFramework(this IAnalyzerResult analyzerRe
         throw new InputException(message);
     }
 
-    internal static bool TargetsFullFramework(this IAnalyzerResult analyzerResult) => GetNuGetFramework(analyzerResult).IsDesktop();
+    internal static bool TargetsFullFramework(this IAnalyzerResult analyzerResult)
+    {
+        var nuGetFramework = GetNuGetFramework(analyzerResult);
+
+        return nuGetFramework.IsDesktop() && (nuGetFramework.Version.Major<4 || nuGetFramework.Version is { Major: 4, Minor: < 8 });
+    }
 
     public static Language GetLanguage(this IAnalyzerResult analyzerResult) => analyzerResult.GetPropertyOrDefault("Language") switch
     {

src/Stryker.Core/Stryker.Core/Initialisation/InputFileResolver.cs

@@ -60,7 +60,8 @@ public IReadOnlyCollection<SourceProjectInfo> ResolveSourceProjectInfos(StrykerO
                     testProjectFileNames = new List<string> { FindTestProject(options.ProjectPath) };
                 }
 
-                var testProjects = testProjectFileNames.Select(testProjectFile => _projectFileReader.AnalyzeProject(testProjectFile, options.SolutionPath, options.TargetFramework)).ToList();
+                var testProjects = testProjectFileNames.Select(testProjectFile =>
+                    _projectFileReader.AnalyzeProject(testProjectFile, options.SolutionPath, options.TargetFramework)).ToList();
 
                 var analyzerResult = _projectFileReader.AnalyzeProject(FindSourceProject(testProjects, options),
                     options.SolutionPath, options.TargetFramework);
@@ -147,12 +148,13 @@ private List<IAnalyzerResult> AnalyzeSolution(StrykerOptions options)
             _logger.LogDebug("Analyzing {count} projects.", manager.Projects.Count);
             try
             {
-                Parallel.ForEach(manager.Projects.Values, project =>
+                Parallel.ForEach(manager.Projects.Values, new ParallelOptions{MaxDegreeOfParallelism = options.DevMode ? 1 : Math.Max(options.Concurrency,1)}, project =>
                 {
                     var projectLogName = Path.GetRelativePath(options.WorkingDirectory, project.ProjectFile.Path);
                     _logger.LogDebug("Analyzing {projectFilePath}", projectLogName);
                     var buildResult = project.Build();
-                    var projectAnalyzerResult = buildResult.Results.FirstOrDefault(a => a.TargetFramework is not null);
+
+                    var projectAnalyzerResult = _projectFileReader.GetAnalyzerResult(buildResult, options.TargetFramework);
                     if (projectAnalyzerResult is not null)
                     {
                         projectsAnalyzerResults.Add(projectAnalyzerResult);

src/Stryker.Core/Stryker.Core/Initialisation/ProjectFileReader.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -17,6 +18,8 @@ IAnalyzerResult AnalyzeProject(string projectFilePath,
             string targetFramework,
             string msBuildPath = null);
         IAnalyzerManager GetAnalyzerManager(string solutionFilePath = null);
+
+        IAnalyzerResult GetAnalyzerResult(IAnalyzerResults results, string targetFramework);
     }
 
     /// <summary>
@@ -51,8 +54,7 @@ public IAnalyzerResult AnalyzeProject(string projectFilePath,
             string msBuildPath = null)
         {
             _logger.LogDebug("Analyzing project file {0}", projectFilePath);
-            var analyzerResult = GetProjectInfo(projectFilePath, solutionFilePath, targetFramework);
-            LogAnalyzerResult(analyzerResult);
+            var analyzerResult = GetAnalyzerResult(GetAnalyzerManager(solutionFilePath).GetProject(projectFilePath).Build(), targetFramework);
 
             if (analyzerResult.Succeeded)
             {
@@ -63,28 +65,21 @@ public IAnalyzerResult AnalyzeProject(string projectFilePath,
                 // buildalyzer failed to find restored packages, retry after nuget restore
                 _logger.LogDebug("Project analyzer result not successful, restoring packages");
                 _nugetRestoreProcess.RestorePackages(solutionFilePath, msBuildPath);
-                analyzerResult = GetProjectInfo(projectFilePath, solutionFilePath, targetFramework);
-            }
-            else
-            {
-                // buildalyzer failed, but seems to work anyway.
-                _logger.LogDebug("Project analyzer result not successful");
+                analyzerResult = GetAnalyzerResult(GetAnalyzerManager(solutionFilePath).GetProject(projectFilePath).Build(), targetFramework);
             }
 
             return analyzerResult;
         }
 
-        /// <summary>
-        /// Checks if project info is already present in solution projects. If not, analyze here.
-        /// </summary>
-        /// <returns></returns>
-        private IAnalyzerResult GetProjectInfo(
-            string projectFilePath,
-            string solutionFilePath,
-            string targetFramework)
+        public IAnalyzerResult GetAnalyzerResult(IAnalyzerResults results, string targetFramework)
         {
-            var analyzerResults = GetAnalyzerManager(solutionFilePath).GetProject(projectFilePath).Build();
-            return SelectAnalyzerResult(analyzerResults, targetFramework);
+            var result = SelectAnalyzerResult(results, targetFramework);
+            if (!result.Succeeded)
+            {
+                _logger.LogDebug("Project analyzer result not successful");
+            }
+            LogAnalyzerResult(result);
+            return result;
         }
 
         private IAnalyzerResult SelectAnalyzerResult(IAnalyzerResults analyzerResults, string targetFramework)
@@ -119,27 +114,36 @@ private IAnalyzerResult SelectAnalyzerResult(IAnalyzerResults analyzerResults, s
             return firstAnalyzerResult;
         }
 
+        private static readonly HashSet<string> ImportantProperties = new() {"Configuration", "Platform", "AssemblyName", "Configurations"};
+
         private void LogAnalyzerResult(IAnalyzerResult analyzerResult)
         {
             // dump all properties as it can help diagnosing build issues for user project.
             _logger.LogTrace("**** Buildalyzer result ****");
 
             _logger.LogTrace("Project: {0}", analyzerResult.ProjectFilePath);
             _logger.LogTrace("TargetFramework: {0}", analyzerResult.TargetFramework);
+            _logger.LogTrace("Succeeded: {0}", analyzerResult.Succeeded);
 
-            foreach (var property in analyzerResult?.Properties ?? new Dictionary<string, string>())
+            var properties = analyzerResult?.Properties ?? new Dictionary<string, string>();
+            foreach (var property in ImportantProperties)
             {
-                _logger.LogTrace("Property {0}={1}", property.Key, property.Value);
+                _logger.LogTrace("Property {0}={1}", property, properties.GetValueOrDefault(property)??"'undefined'");
             }
             foreach (var sourceFile in analyzerResult?.SourceFiles ?? Enumerable.Empty<string>())
             {
                 _logger.LogTrace("SourceFile {0}", sourceFile);
             }
             foreach (var reference in analyzerResult?.References ?? Enumerable.Empty<string>())
             {
-                _logger.LogTrace("References: {0}", reference);
+                _logger.LogTrace("References: {0} (in {1})", Path.GetFileName(reference), Path.GetDirectoryName(reference));
+            }
+
+            foreach (var property in properties)
+            {
+                if (ImportantProperties.Contains(property.Key)) continue; // already logged 
+                _logger.LogTrace("Property {0}={1}", property.Key, property.Value.Replace(Environment.NewLine, "\\n"));
             }
-            _logger.LogTrace("Succeeded: {0}", analyzerResult.Succeeded);
 
             _logger.LogTrace("**** Buildalyzer result ****");
         }