public ReservedBlob Import()

in src/Refasmer/Importer/ImportLogic.cs [457:578]
95 lines of code
19 McCabe index (conditional complexity)

    public ReservedBlob<GuidHandle> Import()
    {
        if (_reader.IsAssembly)
        {
            var srcAssembly = _reader.GetAssemblyDefinition();

            _builder.AddAssembly(ImportValue(srcAssembly.Name), srcAssembly.Version,
                ImportValue(srcAssembly.Culture),
                ImportValue(srcAssembly.PublicKey), srcAssembly.Flags, srcAssembly.HashAlgorithm);
            Debug?.Invoke($"Imported assembly {_reader.ToString(srcAssembly)}");
        }

        var srcModule = _reader.GetModuleDefinition();

        var mvidBlob = _builder.ReserveGuid();

        _builder.AddModule(srcModule.Generation, ImportValue(srcModule.Name), mvidBlob.Handle,
            ImportValue(srcModule.GenerationId),
            ImportValue(srcModule.BaseGenerationId));
        Debug?.Invoke($"Imported module {_reader.ToString(srcModule)}");

        Debug?.Invoke("Importing assembly files");
        foreach (var srcHandle in _reader.AssemblyFiles)
            Import(srcHandle);

        Debug?.Invoke("Preparing type list for import");

        // 1. Process/assign numbers to the initial set of the imported types.
        var internalTypesToPreserve = new HashSet<TypeDefinitionHandle>();
        var initialTypeDefinitions = TypeImportPass(_reader, internalTypesToPreserve, Filter, Trace);

        if (Filter?.OmitNonApiMembers == true)
        {
            // 2. If required, seek for the additional internal types to import.
            Debug?.Invoke("Enumerating the internal types for import.");
            foreach (var internalTypeHandle in CalculateInternalTypesToPreserve(initialTypeDefinitions.Keys))
            {
                internalTypesToPreserve.Add(internalTypeHandle);
            }

            // 3. Enumerate the imported types again, to assign proper final numbering.
            _typeDefinitionCache = TypeImportPass(_reader, internalTypesToPreserve, Filter, Trace);
        }
        else
        {
            _typeDefinitionCache = initialTypeDefinitions;
        }

        Debug?.Invoke("Importing type definitions");
        foreach (var srcHandle in _reader.TypeDefinitions.Where(_typeDefinitionCache.ContainsKey))
        {
            var shouldOmitMembers = ShouldOmitTypeMembers(srcHandle, internalTypesToPreserve);
            var dstHandle = ImportTypeDefinitionSkeleton(srcHandle, shouldOmitMembers);
            if (dstHandle != _typeDefinitionCache[srcHandle])
                throw new Exception(
                    "WTF: type handle mismatch." +
                    $" Original type {_reader.GetFullname(srcHandle)}," +
                    $" already created handle {MetaUtil.RowId(srcHandle)}," +
                    $" new handle {MetaUtil.RowId(dstHandle)}.");
        }

        Debug?.Invoke("Importing type definition accessories");
        foreach (var (srcHandle, dstHandle) in _typeDefinitionCache)
            ImportTypeDefinitionAccessories(srcHandle, dstHandle);

        Debug?.Invoke("Importing method definition accessories");
        foreach (var (srcHandle, dstHandle) in _methodDefinitionCache)
            ImportMethodDefinitionAccessories(srcHandle, dstHandle);

        Debug?.Invoke("Importing field definition accessories");
        foreach (var (srcHandle, dstHandle) in _fieldDefinitionCache)
            ImportFieldDefinitionAccessories(srcHandle, dstHandle);

        Debug?.Invoke("Importing nested classes");
        var nestedTypes = _typeDefinitionCache
            .Select(kv => Tuple.Create(kv.Value, _reader.GetTypeDefinition(kv.Key).GetNestedTypes()))
            .SelectMany(x => x.Item2.Select(y => Tuple.Create(x.Item1, y, Import(y))))
            .Where(x => !x.Item3.IsNil)
            .OrderBy(x => RowId(x.Item3))
            .ToList();

        foreach (var (dstHandle, srcNested, dstNested) in nestedTypes)
        {
            _builder.AddNestedType(dstNested, dstHandle);
            Trace?.Invoke($"Imported nested type {_reader.ToString(srcNested)} -> {RowId(dstNested)}");
        }

        var generic = _typeDefinitionCache
            .Select(kv =>
                Tuple.Create((EntityHandle)kv.Value, _reader.GetTypeDefinition(kv.Key).GetGenericParameters()))
            .Concat(_methodDefinitionCache
                .Select(kv => Tuple.Create((EntityHandle)kv.Value,
                    _reader.GetMethodDefinition(kv.Key).GetGenericParameters())))
            .OrderBy(x => CodedIndex.TypeOrMethodDef(x.Item1))
            .ToList();

        Debug?.Invoke("Importing generic constraints");
        foreach (var (dstHandle, genericParams) in generic)
            ImportGenericConstraints(dstHandle, genericParams);

        Debug?.Invoke("Importing custom attributes");
        foreach (var src in _reader.CustomAttributes)
            Import(src);

        Debug?.Invoke("Importing declarative security attributes");
        foreach (var src in _reader.DeclarativeSecurityAttributes)
            Import(src);

        Debug?.Invoke("Importing exported types");
        foreach (var src in _reader.ExportedTypes)
            Import(src);

        if (!OmitReferenceAssemblyAttr && !MakeMock && !IsReferenceAssembly())
            AddReferenceAssemblyAttribute();

        if (MakeMock)
            _builder.GetOrAddBlob(_ilStream);

        Debug?.Invoke("Importing done");

        return mvidBlob;
    }