private TypeReference Fix(TypeReference type, IGenericParameterProvider context)
        {
            if (type == null || type.IsDefinition)
                return type;

            if (type.IsGenericParameter)
            {
                var genPar = (GenericParameter)type;
                if (!fixedGenericParameters.Contains(genPar))
                {
                    fixedGenericParameters.Add(genPar);
                    FixReferences(genPar.Constraints, context);
                    FixReferences(genPar.CustomAttributes, context);
                }
                return type;
            }

            if (type is TypeSpecification)
                return Fix((TypeSpecification)type, context);
            
            var t2 = repack.GetMergedTypeFromTypeRef(type);
            if (t2 != null)
                return t2;
            
            if (type.IsNested)
                type.DeclaringType = Fix(type.DeclaringType, context);

            if (type.DeclaringType is TypeDefinition)
                return ((TypeDefinition)type.DeclaringType).NestedTypes.FirstOrDefault(x => x.FullName == type.FullName);
            
            return type;
        }

		public void Push (IGenericParameterProvider provider)
		{
			if (stack == null)
				stack = new Collection<IGenericParameterProvider> (1) { provider };
			else
				stack.Add (provider);
		}

        public static void ImportGenericParameters(IGenericParameterProvider imported, Type original)
        {
            var parameters = original.GetGenericTypeDefinition().GetGenericArguments();
            var imported_parameters = imported.GenericParameters;

            for (int i = 0; i < parameters.Length; i++)
                imported_parameters.Add(new GenericParameter(parameters[i].Name, imported));
        }

		internal void CheckProvider (IGenericParameterProvider provider, int count)
		{
			if (!AllowCreation)
				return;

			for (int i = provider.GenericParameters.Count; i < count; i++)
				provider.GenericParameters.Add (new GenericParameter (provider));
		}

        public static void CopyGenericParameters(IGenericParameterProvider source, IGenericParameterProvider target, ReferenceResolver resolver)
        {
            if (!source.HasGenericParameters)
                return;

            foreach (var parameter in source.GenericParameters)
                target.InjectGenericParameter(parameter, resolver);
        }

 public TypeReference GetGenericParameter(GenericParameter genericParamter, IGenericParameterProvider[] paramProviders)
 {
     #if GENERIC
     IGenericParameterProvider context = GetContext(genericParamter, paramProviders);
     return context.GenericParameters[genericParamter.Position];
     #else
     return type;
     #endif
 }

 public static Collection<GenericParameter> GetGenericParameters(
     IGenericParameterProvider self,
     ref Collection<GenericParameter> collection,
     ModuleDefinition module)
 {
     return Mixin.HasImage(module)
         ? module.Read(ref collection, self, (provider, reader) => reader.ReadGenericParameters(provider))
         : collection = new GenericParameterCollection(self);
 }

	static void Process (IGenericParameterProvider provider)
	{
		if (!provider.HasGenericParameters)
			return;


		foreach (var parameter in provider.GenericParameters)
			Process (parameter);
	}

        public GenericParameter(string name, IGenericParameterProvider owner)
            : base(string.Empty, name)
        {
            if (owner == null)
                throw new ArgumentNullException ();

            this.owner = owner;
            this.etype = owner.GenericParameterType == GenericParameterType.Type ? ElementType.Var : ElementType.MVar;
        }

 public GenericContext(IGenericParameterProvider provider)
 {
     if (provider is TypeReference)
         m_type = provider as TypeReference;
     else if (provider is MethodReference) {
         MethodReference meth = provider as MethodReference;
         m_method = meth;
         m_type = meth.DeclaringType;
     }
 }

 public static bool ContainsGenericParameter(IGenericParameterProvider provider, TypeReference parameter)
 {
     foreach (var param in provider.GenericParameters)
     {
         if (param.MetadataToken == parameter.MetadataToken)
         {
             return true;
         }
     }
     return false;
 }

 private void AssertGenericParametersAreIdentical(IGenericParameterProvider expected, IGenericParameterProvider actual)
 {
     Assert.Equal(expected.HasGenericParameters, actual.HasGenericParameters);
     for (var i = 0; i < expected.GenericParameters.Count; i += 1)
     {
         var ap = expected.GenericParameters[i];
         var bp = actual.GenericParameters[i];
         Assert.Equal(ap.Name, bp.Name);
         Assert.Equal(ap.Position, bp.Position);
     }
 }

 public void Process(IGenericParameterProvider provider)
 {
     if (!provider.HasGenericParameters)
     {
         return;
     }
     foreach (var parameter in provider.GenericParameters
                                       .Where(x => x.HasCustomAttributes))
     {
         Process(parameter);
     }
 }

		static TypeReference GenericTypeFor (IGenericParameterProvider context)
		{
			var type = context as TypeReference;
			if (type != null)
				return type.GetElementType ();

			var method = context as MethodReference;
			if (method != null)
				return method.DeclaringType.GetElementType ();

			throw new InvalidOperationException ();
		}

        internal MethodReference Fix(MethodReference method, IGenericParameterProvider context)
        {
            TypeReference declaringType = Fix(method.DeclaringType, context);
            if (method.IsGenericInstance)
            {
                return Fix((GenericInstanceMethod)method, context);
            }
            // if declaring type is in our new merged module, return the definition
            if (declaringType.IsDefinition && !method.IsDefinition)
            {
                MethodDefinition def = new ReflectionHelper(repack).FindMethodDefinitionInType((TypeDefinition)declaringType, method);
                if (def != null)
                    return def;
            }
            method.DeclaringType = declaringType;
            method.ReturnType = Fix(method.ReturnType, method);

            FixReferences(method.Parameters, method);
            FixReferences(method.GenericParameters, method);

            if (!method.IsDefinition &&
                !method.DeclaringType.IsGenericInstance &&
                !method.DeclaringType.IsArray &&
                (method.ReturnType.IsDefinition || method.Parameters.Any(x => x.ParameterType.IsDefinition)))
            {
                var culprit = method.ReturnType.IsDefinition
                                     ? method.ReturnType
                                     : method.Parameters.First(x => x.ParameterType.IsDefinition).ParameterType;
                // warn about invalid merge assembly set, as this method is not gonna work fine (peverify would warn as well)
                repack.WARN("Method reference is used with definition return type / parameter. Indicates a likely invalid set of assemblies, consider one of the following");
                repack.WARN(" - Remove the assembly defining " + culprit + " from the merge");
                repack.WARN(" - Add assembly defining " + method + " to the merge");

                // one case where it'll work correctly however (but doesn't seem common):
                // A references B
                // C references A
                // C is merged into B
            }
            return method;
        }

        /// <summary>
        /// Returns the base-most MethodDefinition (for implicitly or explicitly overridden methods) in this assembly.
        /// (Meaning overridden methods in referenced assemblies do not count, therefore it returns a Definition, not a Reference.)
        /// </summary>
        public void FixOverridenMethodDef(MethodDefinition meth, IGenericParameterProvider context)
        {
            foreach (var ov in meth.Overrides)
            {
                MethodReference fixedOv = Fix(ov, context);
                if (fixedOv.IsDefinition)
                {
                    if (fixedOv.Module == meth.Module)
                    {
                        // it's a Definition, and in our module
                        MethodDefinition fixedOvDef = (MethodDefinition)fixedOv;
                        if (fixedOvDef.IsVirtual)
                            Fix((MethodDefinition) fixedOv, meth);
                    }
                }
            }

            // no explicit overrides found, check implicit overrides
            MethodDefinition @base = MethodMatcher.MapVirtualMethod(meth);
            if (@base != null && @base.IsVirtual)
                Fix(@base, meth);
        }

        private TypeReference Fix(TypeReference type, IGenericParameterProvider context)
        {
            if (type == null || type.IsDefinition)
                return type;

            if (type.IsGenericParameter)
            {
                var genPar = (GenericParameter)type;
                if (!fixedGenericParameters.Contains(genPar))
                {
                    fixedGenericParameters.Add(genPar);
                    FixReferences(genPar.Constraints, context);
                    FixReferences(genPar.CustomAttributes, context);
                }
                return type;
            }

            if (type is TypeSpecification)
            {
                return Fix((TypeSpecification)type, context);
            }
            if (type.IsNested)
            {
                type.DeclaringType = Fix(type.DeclaringType, context);
                // might need to do more
                if (type.DeclaringType is TypeDefinition)
                {
                    return ((TypeDefinition)type.DeclaringType).NestedTypes.First(x => x.FullName == type.FullName);
                }
            }
            else
            {
                type = duplicateHandler.Rename(type);
                return FixImpl(type);
            }
            return type;
        }

        public GenericResolutionWindow(IGenericParameterProvider generic, TypeDefinition context)
        {
            //Component initialization
            InitializeComponent();
            originalGeneric = generic;

            //Sets icon and text
            var node = new ILEditTreeNode(generic, true);
            ImgIcon.Source = (ImageSource)node.Icon;
            LblName.Text = node.Text.ToString();

            //Sets destination type
            LblDestinationType.Text = new ILEditTreeNode(context, true).Text.ToString();

            //Populates the list
            LstParameters.ItemsSource =
                generic.GenericParameters
                .Select(p => {
                    var row = new GenericParameterRowItem() { Name = p.Name, MemberFilter = Injection.MemberFilters.Types, DestinationModule = context.Module, EnclosingType = context };
                    row.HasSelectedParameter = false;
                    row.Selected += Row_Selected;
                    return row;
                }).ToArray();
        }

 public GenericParameter(string name, IGenericParameterProvider owner)
     : base(string.Empty, string.Empty)
 {
     m_name = name;
     m_owner = owner;
 }

 /// <summary>
 /// Format the generic parameters of given provider.
 /// </summary>
 private static string GetGenericParameters(IGenericParameterProvider provider)
 {
     if (!provider.HasGenericParameters) return string.Empty;
     return "<" + string.Join(", ", provider.GenericParameters.Select(x => x.Name)) + ">";
 }