static CodeExpression CreateExpressionFor (CustomAttributeArgument argument)
		{
			if (IsSystemType (argument.Type))
				return new CodeTypeOfExpression (GetCodeTypeReference ((TypeReference) argument.Value));

			return new CodePrimitiveExpression (argument.Value);
		}

		static object GetValue(IProjectContent pc, IEntity member, CustomAttributeArgument argument)
		{
			if (argument.Value is TypeReference)
				return CreateType(pc, member, (TypeReference)argument.Value);
			else
				return argument.Value;
		}

 private CustomAttributeArgument CopyCustomAttributeArg(CustomAttributeArgument yourArgument)
 {
     var type = FixTypeReference(yourArgument.Type);
     var value = yourArgument.Value;
     if (value is CustomAttributeArgument) {
         value = CopyCustomAttributeArg((CustomAttributeArgument) value);
     } else if (value is TypeReference) {
         value = FixTypeReference((TypeReference) value);
     }
     return new CustomAttributeArgument(type, value);
 }

        public static void CopyCustomAttributeNamedArguments(Collection<Mono.Cecil.CustomAttributeNamedArgument> source,
            Collection<Mono.Cecil.CustomAttributeNamedArgument> target, ReferenceResolver resolver)
        {
            foreach (var namedArgument in source)
            {
                var argumentType = resolver.ReferenceType(namedArgument.Argument.Type);
                CustomAttributeArgument argument = new CustomAttributeArgument(argumentType, namedArgument.Argument.Value);

                target.Add(new Mono.Cecil.CustomAttributeNamedArgument(namedArgument.Name, argument));
            }
        }

		static bool TryGetPropertyArgument (ICustomAttribute attribute, string name, out CustomAttributeArgument argument)
		{
			foreach (var namedArg in attribute.Properties) {
				if (namedArg.Name == name) {
					argument = namedArg.Argument;
					return true;
				}
			}

			argument = default (CustomAttributeArgument);
			return false;
		}

    void AddObsoleteAttribute(AttributeData attributeData, Collection<CustomAttribute> customAttributes)
    {
        var customAttribute = new CustomAttribute(ObsoleteConstructorReference);

        var message = ConvertToMessage(attributeData);
        var messageArgument = new CustomAttributeArgument(ModuleDefinition.TypeSystem.String, message);
        customAttribute.ConstructorArguments.Add(messageArgument);

        var isError = GetIsError(attributeData);
        var isErrorArgument = new CustomAttributeArgument(ModuleDefinition.TypeSystem.Boolean, isError);
        customAttribute.ConstructorArguments.Add(isErrorArgument);

        customAttributes.Add(customAttribute);
    }

        public void AddAttribute(Type attributeType, Type[] ctorParamTypes, object[] paramArguments)
        {
            var internalAttributeCtor = attributeType.GetConstructor(ctorParamTypes);
            var internalAttributeCtorRef = TargetModule.Import(internalAttributeCtor);
            var internalAttribute = new CustomAttribute(internalAttributeCtorRef);

            for (int i = 0; i < ctorParamTypes.Count(); i++)
            {
                var paramType = internalAttributeCtorRef.Parameters[i].ParameterType;
                var internalAttributeArgument = new CustomAttributeArgument(paramType, paramArguments[i]);
                internalAttribute.ConstructorArguments.Add(internalAttributeArgument);
            }

            TargetModule.Assembly.CustomAttributes.Add(internalAttribute);
        }

        protected void AddCustomAttribute(MethodDefinition methodDefinition, ModuleDefinition moduleWithAttributeType, 
      CustomAttributeArgument ctorArgument)
        {
            ArgumentUtility.CheckNotNull ("methodDefinition", methodDefinition);
              ArgumentUtility.CheckNotNull ("moduleWithAttributeType", moduleWithAttributeType);

              var attributeCtor = MakeCtorAndReference ( methodDefinition.DeclaringType.Module, moduleWithAttributeType);
              if (attributeCtor.Parameters.Count != 1)
            throw new InvalidOperationException ("There is no custom attribute ctor available that takes one parameter!");

              var customAttribute = new CustomAttribute (attributeCtor);
              customAttribute.ConstructorArguments.Add (ctorArgument);

              if (!methodDefinition.CustomAttributes.Any (att => att.Constructor.FullName == attributeCtor.FullName))
            methodDefinition.CustomAttributes.Add (customAttribute);
        }

 private IEnumerable<ProjectReference> GetCustomAttributeArgumentReferences(
     CustomAttributeArgument customAttributeArgument, AuditEntryParameters parameters)
 {
     TypeDefinition typeDefinition = customAttributeArgument.Value is TypeReference
             ? (customAttributeArgument.Value as TypeReference).Resolve()
             : customAttributeArgument.Type.Resolve();
     if (typeDefinition != null && !parameters.IsTypeChecked(typeDefinition))
     {
         ProjectReference projectReference = parameters.FindProjectReference(typeDefinition.Scope);
         if (projectReference != null)
             yield return projectReference;
         foreach(var pr in
                 m_interfacesTypeWorker.Execute(typeDefinition, parameters))
             yield return pr;
         foreach(var pr in
                 m_classTypeHierarchyWorker.Execute(typeDefinition, parameters))
             yield return pr;
         parameters.AddToCheckedTypes(typeDefinition);
     }
 }

		protected CustomAttributeArgument FixCustomAttributeArgument(ModuleDefinition module, CustomAttributeArgument argument)
		{
			var value = argument.Value;

			if (value is TypeReference)
				value = module.Import(value as TypeReference);

			if (value is CustomAttributeArgument[])
			{
				var arguments = value as CustomAttributeArgument[];
				for (var i = 0; i < arguments.Length; i++)
					arguments[i] = FixCustomAttributeArgument(module, arguments[i]);
			}

			// Used for wrapped CustomAttributeArgument[]
			if (argument.Type.Module == null)
				argument.Type = module.TypeSystem.LookupType(argument.Type.Namespace, argument.Type.Name);

			return new CustomAttributeArgument(module.Import(argument.Type), value);
		}

 private CustomAttributeArgument FixPlatformVersion(CustomAttributeArgument caa)
 {
     return new CustomAttributeArgument(FixPlatformVersion(caa.Type), caa.Value);
 }

 private void WriteArrayValues(CustomAttributeArgument[] array)
 {
     for (int i = 0; i < array.Length; i++)
     {
         if (array[i].Value is bool)
         {
             WriteBooleanLiteral((bool)array[i].Value);
         }
         else if (array[i].Value is string)
         {
             WriteStringLiteral((string)array[i].Value);
         }
         else if (array[i].Value is CustomAttributeArgument[])
         {
             WriteArrayValues(array[i].Value as CustomAttributeArgument[]);
         }
         else
         {
             WriteLiteral(array[i].Value.ToString());
         }
         if (i < array.Length - 1)
         {
             WriteSpace();
         }
     }
 }

		void MarkIfType (CustomAttributeArgument argument)
		{
			var at = argument.Type;
			if (at.IsArray) {
				var et = at.GetElementType ();
				if (et.Namespace != "System" || et.Name != "Type")
					return;

				MarkType (et);
				if (argument.Value == null)
					return;

				foreach (var cac in (CustomAttributeArgument[]) argument.Value)
					MarkWithResolvedScope ((TypeReference) cac.Value);
			} else if (at.Namespace == "System" && at.Name == "Type") {
				MarkType (argument.Type);
				MarkWithResolvedScope ((TypeReference) argument.Value);
			}
		}

		public IConstantValue ReadConstantValue(CustomAttributeArgument arg)
		{
			object value = arg.Value;
			if (value is CustomAttributeArgument) {
				// Cecil uses this representation for boxed values
				arg = (CustomAttributeArgument)value;
				value = arg.Value;
			}
			ITypeReference type = ReadTypeReference(arg.Type);
			CustomAttributeArgument[] array = value as CustomAttributeArgument[];
			if (array != null) {
				// TODO: write unit test for this
				// TODO: are multi-dimensional arrays possible as well?
				throw new NotImplementedException();
			}
			
			TypeReference valueType = value as TypeReference;
			if (valueType != null)
				value = ReadTypeReference(valueType);
			return new SimpleConstantValue(type, value);
		}

		public static string ToString(CustomAttributeArgument argument)
		{
			return argument.Value.ToString();
		}

		void MarkIfType (CustomAttributeArgument argument)
		{
			if (argument.Type.FullName != "System.Type")
				return;

			MarkType (argument.Type);
			MarkType ((TypeReference) argument.Value);
		}

 void addCustomAttributeArgument(CustomAttributeArgument arg)
 {
     pushMember(arg.Type);
 }

 void AnalyzeCustomAttributeArgs(CustomAttributeArgument arg)
 {
     if (arg.Value is TypeReference)
     {
         TypeReference typeRef = arg.Value as TypeReference;
         bool has = false;
         foreach (var i in ivtMap)
             if (i.Key.Name.Name == typeRef.Scope.Name)
             {
                 has = true;
                 break;
             }
         if (has)
         {
             IAnnotationProvider type = (arg.Value as TypeReference).Resolve();
             if (type.Annotations[RenRef] != null)
                 (type.Annotations[RenRef] as List<IReference>).Add(new CustomAttributeTypeReference(arg.Value as TypeReference));
         }
     }
     else if (arg.Value is CustomAttributeArgument[])
         foreach (var i in arg.Value as CustomAttributeArgument[])
             AnalyzeCustomAttributeArgs(i);
 }

        private static void UpdateAssembly( HashSet<IAssemblyInfo> modified, IAssemblyInfo assemblyInfo )
        {
            foreach( var info in GetInternalVisibleToAttributes( assemblyInfo ).ToArray() )
            {
                if( info.ConstructorArguments.Count != ExpectedArgumentsNumber )
                {
                    Log.WarnFormat(
                        "Constructor of InternalVisibleToAttribute has not expected number of arguments. Actual: {0}, expected: {1}.",
                        info.ConstructorArguments.Count,
                        ExpectedArgumentsNumber );
                    continue;
                }

                var argument = GetConstructorArgument( assemblyInfo, info );
                if( argument == null )
                {
                    continue;
                }

                var originalAssemblyName = ( string )argument.Value.Value;

                var signedAssembly = GetMatchingSignedAssembly( modified, originalAssemblyName );

                if( signedAssembly == null )
                {
                    Log.WarnFormat(
                        "InternalVisibleToAttribute for assembly '{0}' will be removed.",
                        originalAssemblyName );
                    assemblyInfo.Assembly.CustomAttributes.Remove( info );
                    continue;
                }

                var assemblyName = string.Format(
                    "{0}, PublicKey={1}",
                    signedAssembly.Assembly.Name.Name,
                    GetPublicKeyToken( signedAssembly ) );
                var newArgument = new CustomAttributeArgument( argument.Value.Type, assemblyName );

                info.ConstructorArguments.Clear();
                info.ConstructorArguments.Add( newArgument );
            }
        }

        public void SwitchFramework()
        {
            //            _asm.MainModule.RuntimeVersion = "";

            for (var x = 0; x < _asm.CustomAttributes.Count; x++)
            {
                if (_asm.CustomAttributes[x].AttributeType.Name == "TargetFrameworkAttribute")
                {
                    _asm.CustomAttributes[x].ConstructorArguments[0] = new CustomAttributeArgument(_asm.MainModule.Import(typeof(String)), ".NETFramework,Version=v4.5");

                    var cs = new CustomAttributeArgument(_asm.MainModule.Import(typeof(String)), ".NET Framework 4.5");
                    _asm.CustomAttributes[x].Properties[0] = new CustomAttributeNamedArgument("FrameworkDisplayName", cs);
                }
            }
        }