/// <summary>
        /// Resolve the given generic parameter to a generic argument.
        /// </summary>
        public TypeReference Resolve(GenericParameter gp)
        {
            var owner = gp.Owner as TypeReference;
            if (owner == null)
                return gp; // Do not resolve generic method parameters for now

            // Try to resolve the owner
            var ownerDef = owner.GetElementType().Resolve();
            if (ownerDef == null)
                return gp;

            // Try to find the owner in our map
            var map = GetTypeToGit();
            GenericInstanceType git;
            if (!map.TryGetValue(ownerDef, out git))
            {
                // No mapping found
                return gp;
            }

            // Replace with the given generic argument
            var result = git.GenericArguments[gp.Position];
            var resultAsGp = result as GenericParameter;
            return (resultAsGp != null) ? Resolve(resultAsGp) : result;
        }

 /// <summary>
 /// Clones the specified generic parameter.
 /// </summary>
 /// <param name="genericParameter">The generic parameter.</param>
 /// <param name="methodDefinition">The method definition.</param>
 /// <returns></returns>
 public static GenericParameter Clone(this GenericParameter genericParameter, MethodDefinition methodDefinition)
 {
     var newGenericParameter = new GenericParameter(methodDefinition);
     newGenericParameter.Attributes = genericParameter.Attributes;
     newGenericParameter.Name = genericParameter.Name;
     return newGenericParameter;
 }

 /// <summary>
 /// Default ctor
 /// </summary>
 public ILGenericParameter(XModule module, GenericParameter p) : 
     base(module)
 {
     this.p = p;
     constraints = new Lazy<XTypeReference[]>(()=>
         p.Constraints.Select(k=>AsTypeReference(module, k)).ToArray());
 }

        public static int GetIndexOfGenericParameter(MethodDefinition method, GenericParameter parameter)
        {
            if (parameter.IsGenericParameter)
            {
                // Genetic parameter has origin on method?
                for (var index = 0; index < method.GenericParameters.Count; index++)
                {
                    if (method.GenericParameters[index].MetadataToken == parameter.MetadataToken)
                    {
                        return index;
                    }
                }

                // Genetic parameter has origin on declared type?
                for (var index = 0; index < method.DeclaringType.GenericParameters.Count; index++)
                {
                    if (method.DeclaringType.GenericParameters[index].MetadataToken ==
                        parameter.MetadataToken)
                    {
                        return index;
                    }
                }
            }

            throw new InvalidOperationException("Could not find generic parameter.");
        }

        private TypeDefinition GenerateTypeA(AssemblyDefinition assembly)
        {
            var objType = assembly.MainModule.Import(typeof (object));

            // define base class
            var aType = new TypeDefinition("A", "", TypeAttributes.Class, objType);
            assembly.MainModule.Types.Add(aType);

            var typeParameter = new GenericParameter("T", aType);
            aType.GenericParameters.Add(typeParameter);

            var baseMethod = new MethodDefinition("Get",
                                                  MethodAttributes.Assem | MethodAttributes.Virtual |
                                                  MethodAttributes.NewSlot, typeParameter);
            aType.Methods.Add(baseMethod);
            baseMethod.DeclaringType = aType;

            var local = new VariableDefinition(typeParameter);
            baseMethod.Body.Variables.Add(local);

            var cil = baseMethod.Body.CilWorker;
            cil.Emit(OpCodes.Ldloca, local);
            cil.Emit(OpCodes.Initobj, typeParameter);
            cil.Emit(OpCodes.Ldloc, local);
            cil.Emit(OpCodes.Ret);
            return aType;
        }

        public override TypeReference Visit(GenericParameter type)
        {
            TypeReference result;
            if (genericTypeMapping.TryGetValue(type, out result))
                return result;

            return base.Visit(type);
        }

 private TypeReference HandleOwnerlessInvalidILCode(GenericParameter genericParameter)
 {
     if (((genericParameter.Type == GenericParameterType.Method) && (this._typeDefinitionContext != null)) && (genericParameter.Position < this._typeDefinitionContext.GenericArguments.Count))
     {
         return this._typeDefinitionContext.GenericArguments[genericParameter.Position];
     }
     return genericParameter.Module.TypeSystem.Object;
 }

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

	static TypeReference CreateConstraint (string @namespace, string name, GenericParameter parameter)
	{
		return new TypeReference (
			@namespace,
			name,
			parameter.Module,
			parameter.Module.AssemblyReferences.First<AssemblyNameReference> (a => a.Name == "mscorlib"),
			false);
	}

		static void AddConstraintsFromType(ITypeParameter tp, GenericParameter g)
		{
			foreach (TypeReference constraint in g.Constraints) {
				if (tp.Method != null) {
					tp.Constraints.Add(CreateType(tp.Class.ProjectContent, tp.Method, constraint));
				} else {
					tp.Constraints.Add(CreateType(tp.Class.ProjectContent, tp.Class, constraint));
				}
			}
		}

    private List<GenericConstraint> CreateGenericConstraints(GenericParameter genericParameter)
    {
      List<GenericConstraint> result = null;

      if ((genericParameter.Attributes & GenericParameterAttributes.ReferenceTypeConstraint) == GenericParameterAttributes.ReferenceTypeConstraint)
      {
        result = new List<GenericConstraint>();

        result.Add(new BuiltInGenericConstraint(BuiltInGenericConstraintsTypes.Class));
      }
      else if ((genericParameter.Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) == GenericParameterAttributes.NotNullableValueTypeConstraint)
      {
        result = new List<GenericConstraint>();

        result.Add(new BuiltInGenericConstraint(BuiltInGenericConstraintsTypes.Struct));
      }

      ConstraintCollection baseOrInterfaceConstraints = genericParameter.Constraints;

      if (baseOrInterfaceConstraints != null)
      {
        if (result == null) { result = new List<GenericConstraint>(); }

        for (int i = 0; i < baseOrInterfaceConstraints.Count; i++)
        {
          TypeReference baseTypeOrInterface = baseOrInterfaceConstraints[i];

          if (baseTypeOrInterface.FullName == "System.ValueType")
          {
            continue;
          }

          if (Utils.IsGenericParameter(baseTypeOrInterface))
          {
            result.Add(new NakedTypeConstraint(baseTypeOrInterface.Name));
          }
          else
          {
            string[] readableForms = Tools.GetHumanReadableForms(baseTypeOrInterface);

            result.Add(new TypeGenericConstraint(readableForms[0]));
          }
        }
      }

      if ((genericParameter.Attributes & GenericParameterAttributes.DefaultConstructorConstraint) == GenericParameterAttributes.DefaultConstructorConstraint
       && (genericParameter.Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0)
      {
        if (result == null) { result = new List<GenericConstraint>(); }

        result.Add(new BuiltInGenericConstraint(BuiltInGenericConstraintsTypes.New));
      }

      return result;
    }

 public static bool GenericParameterEquals(GenericParameter genericParameter, GenericParameter genericParameter2)
 {
     if (genericParameter.Position != genericParameter.Position)
     {
         return false;
     }
     if (!TypeReferenceEquals(genericParameter, genericParameter2, false))
     {
         return false;
     }
     return true; // TODO: Implement this properly
 }

 private static void CloneGenericParameterProperties(GenericParameter genericParameter,
     GenericParameter newGenericParameter)
 {
     newGenericParameter.Attributes = genericParameter.Attributes;
     genericParameter.Constraints.ForEach(gp => newGenericParameter.Constraints.Add(gp));
     genericParameter.CustomAttributes.ForEach(ca => newGenericParameter.CustomAttributes.Add(ca));
     newGenericParameter.DeclaringType = genericParameter.DeclaringType;
     genericParameter.GenericParameters.ForEach(gp => newGenericParameter.GenericParameters.Add(gp));
     newGenericParameter.HasDefaultConstructorConstraint = genericParameter.HasDefaultConstructorConstraint;
     newGenericParameter.IsContravariant = genericParameter.IsContravariant;
     newGenericParameter.IsCovariant = genericParameter.IsCovariant;
     newGenericParameter.IsNonVariant = genericParameter.IsNonVariant;
 }

 TypeReference GetEnumType(CustomAttribute attribute, GenericParameter parameter)
 {
     if (attribute.HasConstructorArguments)
     {
         var typeReference = (TypeReference) attribute.ConstructorArguments[0].Value;
         if (!typeReference.IsEnumType())
         {
             var message = $"The type '{typeReference.FullName}' is not an enum type. Only enum types are permitted in an EnumConstraintAttribute.";
             throw new WeavingException(message);
         }
         return typeReference;
     }
     return CreateConstraint("System", "Enum", parameter);
 }

        private static string CollectConstraints(GenericParameter param)
        {
            List<string> constraints = new List<string>();

            if (param.HasDefaultConstructorConstraint)
            {
                constraints.Add("new()");
            }

            if(param.HasReferenceTypeConstraint)
            {
                constraints.Add("class");
            }

            constraints.AddRange(param.Constraints.Select(constraint => constraint.ToString()));

            return string.Join(", ", constraints.ToArray());
        }

        public static void InjectGenericParameter(this IGenericParameterProvider owner, GenericParameter parameter, ReferenceResolver resolver)
        {
            GenericParameter newParameter = new GenericParameter(parameter.Name, owner)
            {
                Attributes = parameter.Attributes
            };

            owner.GenericParameters.Add(newParameter);

            MetadataBuilderHelper.CopyCustomAttributes(newParameter, parameter, resolver);

            foreach (var constraint in parameter.Constraints)
            {
                if (owner is MethodReference)
                    newParameter.Constraints.Add(resolver.ReferenceType(constraint, owner, ((MethodReference)owner).DeclaringType));
                else
                    newParameter.Constraints.Add(resolver.ReferenceType(constraint, owner));
            }
        }

        public MethodReference GetCallableObjectFactoryCreateMethod(AssemblyDefinition assemblyDef, ModuleDefinition moduleDefinition, TypeReference instantiatedType, IAssemblyTracker tracker)
        {
            var tempRef = GetOrCreateRemotionInterfacesReference (assemblyDef, moduleDefinition, tracker);

              var objectFactoryReference = new TypeReference (_objectFactoryNamespace, _objectFactoryName, moduleDefinition, tempRef);
              var paramListReference = new TypeReference (_paramListNamespace, _paramListName, moduleDefinition, tempRef);

              var createReference = new MethodReference ("Create", moduleDefinition.TypeSystem.Void, objectFactoryReference);
              var createTypeParam = new GenericParameter ("T", createReference);

              createReference.GenericParameters.Add (createTypeParam);
              createReference.ReturnType = createTypeParam;
              createReference.Parameters.Add (new ParameterDefinition (moduleDefinition.TypeSystem.Boolean));
              createReference.Parameters.Add (new ParameterDefinition (paramListReference));
              createReference.Parameters.Add (new ParameterDefinition (new ArrayType (moduleDefinition.TypeSystem.Object)));

              var instanceMethod = new GenericInstanceMethod (createReference);
              instanceMethod.GenericArguments.Add (instantiatedType);

              return instanceMethod;
        }

	static void Process (GenericParameter parameter)
	{
		if (!parameter.HasCustomAttributes)
			return;

		var attributes = parameter.CustomAttributes;
		for (int i = 0; i < attributes.Count; i++) {
			var attribute = attributes [i];
			if (IsDelegateConstraintAttribute (attribute)) {
				parameter.Attributes = GenericParameterAttributes.NonVariant;
				parameter.Constraints.Clear ();
				parameter.Constraints.Add (CreateConstraint ("System", "Delegate", parameter));
				attributes.RemoveAt (i--);
			} else if (IsEnumConstraintAttribute (attribute)) {
				parameter.Attributes = GenericParameterAttributes.NonVariant;
				parameter.Constraints.Clear ();
				parameter.Constraints.Add (CreateConstraint ("System", "Enum", parameter));
				attributes.RemoveAt (i--);
			}
		}
	}

    void Process(GenericParameter parameter)
    {
        var hasDelegateConstraint = false;
        var hasEnumConstraint = false;
        var attributes = parameter.CustomAttributes;
        for (var i = 0; i < attributes.Count; i++)
        {
            var attribute = attributes[i];
            if (IsDelegateConstraintAttribute(attribute))
            {
                hasDelegateConstraint = true;
                parameter.Attributes = GenericParameterAttributes.NonVariant;
                parameter.Constraints.Clear();

                var typeReference = GetDelegateType(attribute, parameter);

                parameter.Constraints.Add(typeReference);
                attributes.RemoveAt(i--);
            }
            else if (IsEnumConstraintAttribute(attribute))
            {
                hasEnumConstraint = true;
                parameter.Attributes = GenericParameterAttributes.NonVariant | GenericParameterAttributes.NotNullableValueTypeConstraint;
                parameter.Constraints.Clear();

                var typeReference = GetEnumType(attribute, parameter);

                parameter.Constraints.Add(typeReference);
                attributes.RemoveAt(i--);
            }
        }
        if (hasDelegateConstraint && hasEnumConstraint)
        {
            throw new WeavingException("Cannot contain both [EnumConstraint] and [DelegateConstraint].");
        }
    }

        public TypeDefinition GenerateClass()
        {
            var commandClass = new TypeDefinition(
                GeneratedCommandClassNamespace
                , GeneratedCommandClassName
                , DefaultTypeAttributesForCommand
                , Assets.TypeReferences.Object);

            commandClass.Interfaces.Add(Assets.TypeReferences.ICommand);

            var genericParameter = new GenericParameter("TParameter", commandClass);
            commandClass.GenericParameters.Add(genericParameter);


            AddFields(commandClass);
            AddConstructors(commandClass);
            AddExecuteMethod(commandClass);
            AddCanExecuteMethod(commandClass);
            Assets.AddCanExecuteChangedEvent(commandClass);

            ModuleDefinition.Types.Add(commandClass);
            Assets.DelegateCommandImplementationWasInjected = true;
            return commandClass;
        }