private TypeDefinitionHandle ImportTypeDefinitionSkeleton()

in src/Refasmer/Importer/ImportLogic.cs [38:149]
87 lines of code
23 McCabe index (conditional complexity)

    private TypeDefinitionHandle ImportTypeDefinitionSkeleton(TypeDefinitionHandle srcHandle, bool omitMembers)
    {
        var src = _reader.GetTypeDefinition(srcHandle);

        var dstHandle = _builder.AddTypeDefinition(src.Attributes, ImportValue(src.Namespace), ImportValue(src.Name),
            Import(src.BaseType), NextFieldHandle(), NextMethodHandle());

        Trace?.Invoke($"Imported {_reader.ToString(src)} -> {RowId(dstHandle)}");

        if (omitMembers) return dstHandle;

        using var _ = WithLogPrefix($"[{_reader.ToString(src)}]");

        var isValueType = _reader.GetFullname(src.BaseType) == "System::ValueType";
        var isEnum = _reader.GetFullname(src.BaseType) == "System::Enum";
        var forcePreservePrivateInstanceFields = isValueType && Filter?.OmitNonApiMembers == false;
        var forcePreserveAllFields = isEnum && Filter?.OmitNonApiMembers == false;

        List<FieldDefinition>? importedInstanceFields = null;
        List<FieldDefinition>? skippedInstanceFields = null;

        if (forcePreservePrivateInstanceFields)
            Trace?.Invoke($"{_reader.ToString(src)} is ValueType, all fields should be imported");
        else if (forcePreserveAllFields)
            Trace?.Invoke($"{_reader.ToString(src)} is an Enum, all fields should be imported.");
        else
        {
            importedInstanceFields = [];
            skippedInstanceFields = [];
        }

        foreach (var srcFieldHandle in src.GetFields())
        {
            var srcField = _reader.GetFieldDefinition(srcFieldHandle);
            var isStatic = (srcField.Attributes & FieldAttributes.Static) != 0;
            var isForcedToInclude =
                (forcePreservePrivateInstanceFields && !isStatic)
                || forcePreserveAllFields;

            if (!isForcedToInclude && Filter?.AllowImport(srcField, _reader) == false)
            {
                Trace?.Invoke($"Not imported {_reader.ToString(srcField)}");
                if (!isStatic)
                    skippedInstanceFields?.Add(srcField);

                continue;
            }

            var dstFieldHandle = _builder.AddFieldDefinition(srcField.Attributes, ImportValue(srcField.Name),
                ImportSignatureWithHeader(srcField.Signature));
            _fieldDefinitionCache.Add(srcFieldHandle, dstFieldHandle);
            Trace?.Invoke($"Imported {_reader.ToString(srcFieldHandle)} -> {RowId(dstFieldHandle)}");
            if (!isStatic)
                importedInstanceFields?.Add(srcField);
        }

        if (!forcePreservePrivateInstanceFields && !forcePreserveAllFields)
            PostProcessSkippedValueTypeFields(skippedInstanceFields!, importedInstanceFields!);

        var implementations = GetAllowlistedInterfaceMethodImplementations(src);

        foreach (var srcMethodHandle in src.GetMethods())
        {
            var srcMethod = _reader.GetMethodDefinition(srcMethodHandle);

            if (!AllowImportMethod(implementations, srcMethodHandle, srcMethod))
            {
                Trace?.Invoke($"Not imported {_reader.ToString(srcMethod)}");
                continue;
            }

            var dstSignature = ImportSignatureWithHeader(srcMethod.Signature);

            if (dstSignature.IsNil)
            {
                Trace?.Invoke($"Not imported because of signature {_reader.ToString(srcMethod)}");
                continue;
            }

            var isAbstract = srcMethod.Attributes.HasFlag(MethodAttributes.Abstract);
            var bodyOffset = !isAbstract && MakeMock ? MakeMockBody(srcMethodHandle) : -1;

            var dstMethodHandle = _builder.AddMethodDefinition(srcMethod.Attributes, srcMethod.ImplAttributes,
                ImportValue(srcMethod.Name), dstSignature, bodyOffset, NextParameterHandle());
            _methodDefinitionCache.Add(srcMethodHandle, dstMethodHandle);
            Trace?.Invoke($"Imported {_reader.ToString(srcMethod)} -> {RowId(dstMethodHandle)}");

            using var __ = WithLogPrefix($"[{_reader.ToString(srcMethod)}]");
            foreach (var srcParameterHandle in srcMethod.GetParameters())
            {
                var srcParameter = _reader.GetParameter(srcParameterHandle);
                var dstParameterHandle = _builder.AddParameter(srcParameter.Attributes,
                    ImportValue(srcParameter.Name), srcParameter.SequenceNumber);
                _parameterCache.Add(srcParameterHandle, dstParameterHandle);
                Trace?.Invoke($"Imported {_reader.ToString(srcParameter)} -> {RowId(dstParameterHandle)}");

                var defaultValue = srcParameter.GetDefaultValue();

                if (!defaultValue.IsNil)
                    ImportDefaultValue(defaultValue, dstParameterHandle);


                if (!srcParameter.GetMarshallingDescriptor().IsNil)
                {
                    _builder.AddMarshallingDescriptor(dstParameterHandle, ImportValue(srcParameter.GetMarshallingDescriptor()));
                    Trace?.Invoke($"Imported marshalling descriptor {_reader.ToString(srcParameter.GetMarshallingDescriptor())}");
                }
            }
        }

        return dstHandle;
    }