public void Repack()

in ILRepack/ILRepack.cs [259:406]
116 lines of code
18 McCabe index (conditional complexity)

        public void Repack()
        {
            var timer = new Stopwatch();
            timer.Start();
            Options.Validate();
            PrintRepackHeader();

            var actualOutFile = Options.OutputFile;
            Options.OutputFile = GetTempFile(Options.OutputFile);
            _reflectionHelper = new ReflectionHelper(this);
            ResolveSearchDirectories();

            // Read input assemblies only after all properties are set.
            ReadInputAssemblies();

            _platformFixer = new PlatformFixer(this, PrimaryAssemblyMainModule.Runtime);
            _mappingHandler = new MappingHandler();
            bool hadStrongName = PrimaryAssemblyDefinition.Name.HasPublicKey;

            ModuleKind kind = PrimaryAssemblyMainModule.Kind;
            if (Options.TargetKind.HasValue)
            {
                switch (Options.TargetKind.Value)
                {
                    case Kind.Dll: kind = ModuleKind.Dll; break;
                    case Kind.Exe: kind = ModuleKind.Console; break;
                    case Kind.WinExe: kind = ModuleKind.Windows; break;
                }
            }
            TargetRuntime runtime = ParseTargetPlatform();

            // change assembly's name to correspond to the file we create
            string mainModuleName = Path.GetFileNameWithoutExtension(Options.OutputFile);

            if (TargetAssemblyDefinition == null)
            {
                AssemblyNameDefinition asmName = Clone(PrimaryAssemblyDefinition.Name);
                asmName.Name = mainModuleName;
                TargetAssemblyDefinition = AssemblyDefinition.CreateAssembly(asmName, mainModuleName,
                    new ModuleParameters()
                    {
                        Kind = kind,
                        Architecture = PrimaryAssemblyMainModule.Architecture,
                        AssemblyResolver = GlobalAssemblyResolver,
                        Runtime = runtime
                    });
            }
            else
            {
                // TODO: does this work or is there more to do?
                TargetAssemblyMainModule.Kind = kind;
                TargetAssemblyMainModule.Runtime = runtime;

                TargetAssemblyDefinition.Name.Name = mainModuleName;
                TargetAssemblyMainModule.Name = mainModuleName;
            }
            // set the main module attributes
            TargetAssemblyMainModule.Attributes = PrimaryAssemblyMainModule.Attributes;
            var win32ResourceStep = new Win32ResourceStep(Logger, this, _aspOffsets);

            if (Options.Version != null)
                TargetAssemblyDefinition.Name.Version = Options.Version;

            _lineIndexer = new IKVMLineIndexer(this, Options.LineIndexation);
            var signingStep = new SigningStep(this, Options);
            var isUnixEnvironment = Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix;

            using (var sourceServerDataStep = GetSourceServerDataStep(isUnixEnvironment))
            {
                List<IRepackStep> repackSteps = new List<IRepackStep>
                {
                    win32ResourceStep,
                    signingStep,
                    new ReferencesRepackStep(Logger, this),
                    new TypesRepackStep(Logger, this, _repackImporter, Options),
                    new ResourcesRepackStep(Logger, this, Options),
                    new AttributesRepackStep(Logger, this, _repackImporter, Options),
                    new ReferencesFixStep(Logger, this, _repackImporter, Options),
                    new XamlResourcePathPatcherStep(Logger, this),
                    sourceServerDataStep
                };

                foreach (var step in repackSteps)
                {
                    step.Perform();
                }

                var parameters = new WriterParameters
                {
                    StrongNameKeyBlob = signingStep.KeyBlob,
                    WriteSymbols = Options.DebugInfo && PrimaryAssemblyMainModule.SymbolReader != null,
                    SymbolWriterProvider = PrimaryAssemblyMainModule.SymbolReader?.GetWriterProvider(),
                };
                // create output directory if it does not exist
                var outputDir = Path.GetDirectoryName(Options.OutputFile);
                if (!string.IsNullOrEmpty(outputDir) && !Directory.Exists(outputDir))
                {
                    Logger.Info("Output directory does not exist. Creating output directory: " + outputDir);
                    Directory.CreateDirectory(outputDir);
                }

                Logger.Info("Writing output assembly to disk");
                TargetAssemblyDefinition.Write(Options.OutputFile, parameters);
                
                sourceServerDataStep.Write();

                foreach (var assembly in MergedAssemblies)
                {
                    assembly.Dispose();
                }
                
                TargetAssemblyDefinition.Dispose();
                GlobalAssemblyResolver.Dispose();

                win32ResourceStep.Patch(Options.OutputFile);

                // resign output assembly after patching win32 resources
                if (signingStep.KeyBlob != null)
                {
                    var rp = new ReaderParameters(ReadingMode.Immediate) { AssemblyResolver = GlobalAssemblyResolver };

                    using var ad = AssemblyDefinition.ReadAssembly(Options.OutputFile, rp);
                    Options.OutputFile = GetTempFile(Options.OutputFile);
                    ad.Write(Options.OutputFile, parameters);
                }

                MoveTempFile(Options.OutputFile, actualOutFile);
                Options.OutputFile = actualOutFile;

                // If this is an executable and we are on linux/osx we should copy file permissions from
                // the primary assembly
                if (isUnixEnvironment)
                {
                    Logger.Info("Copying permissions from " + PrimaryAssemblyFile);
                    LibC.Stat(PrimaryAssemblyFile, out var stat);
                    LibC.ChMod(Options.OutputFile, stat.st_mode);
                }
                if (hadStrongName && !TargetAssemblyDefinition.Name.HasPublicKey)
                    Options.StrongNameLost = true;

                // nice to have, merge .config (assembly configuration file) & .xml (assembly documentation)
                ConfigMerger.Process(this);
                if (Options.XmlDocumentation)
                    DocumentationMerger.Process(this);
            }

            Logger.Info($"Finished in {timer.Elapsed}");
        }