private static BenchmarkRunInfo MethodsToBenchmarksWithFullConfig(Type containingType, MethodInfo[] benchmarkMethods, ReadOnlyConfig fullConfig)
        {
            if (fullConfig == null)
            {
                throw new ArgumentNullException(nameof(fullConfig));
            }

            var helperMethods = containingType.GetMethods(); // benchmarkMethods can be filtered, without Setups, look #564

            var globalSetupMethods      = GetAttributedMethods <GlobalSetupAttribute>(helperMethods, "GlobalSetup");
            var globalCleanupMethods    = GetAttributedMethods <GlobalCleanupAttribute>(helperMethods, "GlobalCleanup");
            var iterationSetupMethods   = GetAttributedMethods <IterationSetupAttribute>(helperMethods, "IterationSetup");
            var iterationCleanupMethods = GetAttributedMethods <IterationCleanupAttribute>(helperMethods, "IterationCleanup");

            var targetMethods = benchmarkMethods.Where(method => method.HasAttribute <BenchmarkAttribute>()).ToArray();

            var parameterDefinitions   = GetParameterDefinitions(containingType);
            var parameterInstancesList = parameterDefinitions.Expand();

            var rawJobs = fullConfig.GetJobs().ToArray();

            if (rawJobs.IsEmpty())
            {
                rawJobs = new[] { Job.Default }
            }
            ;
            var jobs = rawJobs.Distinct().ToArray();

            var targets = GetTargets(targetMethods, containingType, globalSetupMethods, globalCleanupMethods, iterationSetupMethods, iterationCleanupMethods).ToArray();

            var benchmarks = new List <Benchmark>();

            foreach (var target in targets)
            {
                var argumentsDefinitions = GetArgumentsDefinitions(target.Method, target.Type).ToArray();

                benchmarks.AddRange(
                    from job in jobs
                    from parameterInstance in parameterInstancesList
                    from argumentDefinition in argumentsDefinitions
                    select Benchmark.Create(target, job, new ParameterInstances(parameterInstance.Items.Concat(argumentDefinition.Items).ToArray()))
                    );
            }

            var filters            = fullConfig.GetFilters().ToList();
            var filteredBenchmarks = GetFilteredBenchmarks(benchmarks, filters);

            var orderProvider = fullConfig.GetOrderProvider() ?? DefaultOrderProvider.Instance;

            return(new BenchmarkRunInfo(
                       orderProvider.GetExecutionOrder(filteredBenchmarks).ToArray(),
                       containingType,
                       fullConfig));
        }
        public static BenchmarkRunInfo[] SourceToBenchmarks(string source, IConfig config = null)
        {
            string benchmarkContent   = source;
            var    cSharpCodeProvider = new CSharpCodeProvider();
            var    compilerParameters = new CompilerParameters(
                new[]
            {
                "mscorlib.dll",
                "System.dll",
                "System.Core.dll"
            })
            {
                CompilerOptions  = "/unsafe /optimize",
                GenerateInMemory = false,
                OutputAssembly   = Path.Combine(
                    Path.GetDirectoryName(typeof(Benchmark).Assembly.Location),
                    $"{Path.GetFileNameWithoutExtension(Path.GetTempFileName())}.dll")
            };

            compilerParameters.ReferencedAssemblies.Add(typeof(Benchmark).Assembly.Location);
            var compilerResults = cSharpCodeProvider.CompileAssemblyFromSource(compilerParameters, benchmarkContent);

            if (compilerResults.Errors.HasErrors)
            {
                var logger = config?.GetCompositeLogger() ?? HostEnvironmentInfo.FallbackLogger;

                compilerResults.Errors.Cast <CompilerError>().ToList().ForEach(error => logger.WriteLineError(error.ErrorText));
                return(Array.Empty <BenchmarkRunInfo>());
            }

            var types = compilerResults.CompiledAssembly.GetTypes();

            var resultBenchmarks = new List <BenchmarkRunInfo>();

            foreach (var type in types)
            {
                var runInfo    = TypeToBenchmarks(type, config);
                var benchmarks = runInfo.Benchmarks.Select(b =>
                {
                    var target = b.Target;
                    return(Benchmark.Create(
                               new Target(target.Type, target.Method, target.GlobalSetupMethod, target.GlobalCleanupMethod,
                                          target.IterationSetupMethod, target.IterationCleanupMethod,
                                          target.MethodDisplayInfo, benchmarkContent, target.Baseline, target.Categories, target.OperationsPerInvoke),
                               b.Job,
                               b.Parameters));
                });
                resultBenchmarks.Add(
                    new BenchmarkRunInfo(benchmarks.ToArray(), runInfo.Type, runInfo.Config));
            }

            return(resultBenchmarks.ToArray());
        }