public ReportingResult ComputeReport()

in src/lib/Microsoft.Fx.Portability/Reporting/ReportGenerator.cs [16:85]
60 lines of code
9 McCabe index (conditional complexity)

        public ReportingResult ComputeReport(
            IList<FrameworkName> targets,
            string submissionId,
            AnalyzeRequestFlags requestFlags,
            IDictionary<MemberInfo, ICollection<AssemblyInfo>> allDependencies,
            IList<MemberInfo> missingDependencies,
            IDictionary<string, ICollection<string>> unresolvedAssemblies,
            IList<string> unresolvedUserAssemblies,
            IEnumerable<string> assembliesWithErrors,
            IList<NuGetPackageInfo> nugetPackages)
        {
            var types = allDependencies.Keys.Where(dep => dep.TypeDocId == null);
            ReportingResult result = new ReportingResult(targets, types, submissionId, requestFlags);

            missingDependencies
                .AsParallel()
                .ForAll((Action<MemberInfo>)((item) =>
                {
                    // the calling assemblies are in Finder...
                    if (allDependencies == null)
                    {
                        lock (result)
                        {
                            result.AddMissingDependency(null, item, item.RecommendedChanges);
                        }
                    }
                    else
                    {
                        if (!allDependencies.TryGetValue(item, out var calledIn))
                        {
                            return;
                        }

                        foreach (var callingAsm in calledIn)
                        {
                            lock (result)
                            {
                                result.AddMissingDependency(callingAsm, item, item.RecommendedChanges);
                            }
                        }
                    }
                }));

            if (assembliesWithErrors != null)
            {
                foreach (var error in assembliesWithErrors)
                {
                    result.AddAssemblyWithError(error);
                }
            }

            foreach (var unresolvedAssembly in unresolvedUserAssemblies)
            {
                result.AddUnresolvedUserAssembly(unresolvedAssembly, unresolvedAssemblies == null ? Enumerable.Empty<string>() : unresolvedAssemblies[unresolvedAssembly]);
            }

            // Compute per assembly report
            if (allDependencies != null)
            {
                var perAssemblyUsage = ComputePerAssemblyUsage(targets, missingDependencies, allDependencies);
                result.SetAssemblyUsageInfo(perAssemblyUsage);

                // Compute the map of assemblyInfo to name
                var assemblyNameMap = ComputeAssemblyNames(perAssemblyUsage);
                result.SetAssemblyNameMap(assemblyNameMap);
            }

            result.NuGetPackages = nugetPackages;
            return result;
        }