private TypeSpecification Fix()

in ILRepack/ReferenceFixator.cs [483:559]
69 lines of code
15 McCabe index (conditional complexity)

        private TypeSpecification Fix(TypeSpecification type)
        {
            var fet = Fix(type.ElementType);
            if (type is ArrayType)
            {
                var array = (ArrayType)type;
                var imported_array = new ArrayType(fet);
                if (array.IsVector)
                    return imported_array;

                var dimensions = array.Dimensions;
                var imported_dimensions = imported_array.Dimensions;

                imported_dimensions.Clear();

                for (int i = 0; i < dimensions.Count; i++)
                {
                    var dimension = dimensions[i];

                    imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
                }

                return imported_array;
            }
            if (type is PointerType)
                return new PointerType(fet);
            if (type is ByReferenceType)
                return new ByReferenceType(fet);
            if (type is PinnedType)
                return new PinnedType(fet);
            if (type is SentinelType)
                return new SentinelType(fet);
            if (type is OptionalModifierType)
            {
                TypeReference fmt = Fix(((OptionalModifierType)type).ModifierType);
                return new OptionalModifierType(fmt, fet);
            }
            if (type is RequiredModifierType)
            {
                TypeReference fmt = Fix(((RequiredModifierType)type).ModifierType);
                return new RequiredModifierType(fmt, fet);
            }
            if (type is GenericInstanceType)
            {
                var instance = (GenericInstanceType)type;
                var imported_instance = new GenericInstanceType(fet);

                var arguments = instance.GenericArguments;
                var imported_arguments = imported_instance.GenericArguments;

                for (int i = 0; i < arguments.Count; i++)
                    imported_arguments.Add(Fix(arguments[i]));

                return imported_instance;
            }
            if (type is FunctionPointerType)
            {
                var funcPtr = (FunctionPointerType)type;
                var imported_instance = new FunctionPointerType()
                {
                    HasThis = funcPtr.HasThis,
                    ExplicitThis = funcPtr.ExplicitThis,
                    CallingConvention = funcPtr.CallingConvention,
                    ReturnType = Fix(funcPtr.ReturnType)
                };
                if (funcPtr.HasParameters)
                {
                    foreach (var pd in funcPtr.Parameters)
                    {
                        imported_instance.Parameters.Add(pd);
                    }
                    FixReferences(imported_instance.Parameters);
                }
                return imported_instance;
            }
            throw new InvalidOperationException();
        }