private void GetAttributeUsage()
		{
			if (analyzedType.HasCustomAttributes) {
				foreach (CustomAttribute ca in analyzedType.CustomAttributes) {
					TypeReference t = ca.AttributeType;
					if (t.Name == "AttributeUsageAttribute" && t.Namespace == "System") {
						this.usage = (AttributeTargets)ca.ConstructorArguments[0].Value;
						if (ca.ConstructorArguments.Count > 1) {
							this.allowMutiple = (bool)ca.ConstructorArguments[1].Value;
							this.inherited = (bool)ca.ConstructorArguments[2].Value;
						}
						if (ca.HasProperties) {
							foreach (var namedArgument in ca.Properties) {
								switch (namedArgument.Name) {
									case "AllowMultiple":
										this.allowMutiple = (bool)namedArgument.Argument.Value;
										break;
									case "Inherited":
										this.inherited = (bool)namedArgument.Argument.Value;
										break;
								}
							}
						}
					}
				}
			}
		}

		internal AttributeGen(AttributeTargets target, AttributeType attributeType, object[] args)
		{
			if (args != null)
			{
				foreach (object arg in args)
				{
					CheckValue(arg);
				}
			}

			// TODO: target validation

			this.attributeType = attributeType;

			Operand[] argOperands;
			if (args == null || args.Length == 0)
			{
				this.args = EmptyArray<object>.Instance;
				argOperands = Operand.EmptyArray;
			}
			else
			{
				this.args = args;
				argOperands = new Operand[args.Length];
				for (int i = 0; i < args.Length; i++)
				{
					argOperands[i] = GetOperand(args[i]);
				}
			}

			this.ctor = TypeInfo.FindConstructor(attributeType, argOperands);
		}

		void GetAttributeUsage() {
			if (analyzedType.HasCustomAttributes) {
				foreach (CustomAttribute ca in analyzedType.CustomAttributes) {
					ITypeDefOrRef t = ca.AttributeType;
					if (t != null && t.Name == "AttributeUsageAttribute" && t.Namespace == "System" &&
						ca.ConstructorArguments.Count > 0 &&
						ca.ConstructorArguments[0].Value is int) {
						usage = (AttributeTargets)ca.ConstructorArguments[0].Value;
						if (ca.ConstructorArguments.Count > 2) {
							if (ca.ConstructorArguments[1].Value is bool)
								allowMutiple = (bool)ca.ConstructorArguments[1].Value;
							if (ca.ConstructorArguments[2].Value is bool)
								inherited = (bool)ca.ConstructorArguments[2].Value;
						}
						foreach (var namedArgument in ca.Properties) {
							switch (namedArgument.Name) {
							case "AllowMultiple":
								if (namedArgument.Argument.Value is bool)
									allowMutiple = (bool)namedArgument.Argument.Value;
								break;
							case "Inherited":
								if (namedArgument.Argument.Value is bool)
									inherited = (bool)namedArgument.Argument.Value;
								break;
							}
						}
					}
				}
			}
		}

 public AttributeBlockNode(Token token,
                           AttributeTargets location,
                           ParseNodeList attributes)
     : base(ParseNodeType.AttributeBlock, token) {
     _location = location;
     _attributes = GetParentedNodeList(attributes);
 }

 internal AttributeUsageAttribute(AttributeTargets validOn, bool allowMultiple, bool inherited)
 {
     this.m_attributeTarget = AttributeTargets.All;
     this.m_inherited = true;
     this.m_attributeTarget = validOn;
     this.m_allowMultiple = allowMultiple;
     this.m_inherited = inherited;
 }

 public AttributeUsageTest(MemberInfo member,
                           AttributeTargets validOn,
                           bool allowMultiple,
                           bool inherited)
     : base(member)
 {
     ValidOn = validOn;
     AllowMultiple = allowMultiple;
     Inherited = inherited;
 }

 public void AttributeCanBeAppliedToCodeElementsSupportedBySubstituteAttributeRelay(AttributeTargets expectedTarget)
 {
     // Fixture setup
     var attributeUsage = typeof(SubstituteAttribute).GetCustomAttributes(false)
         .OfType<AttributeUsageAttribute>().Single();
     // Exercise system
     Assert.Equal(expectedTarget, attributeUsage.ValidOn & expectedTarget);
     // Verify outcome
     // Teardown
 }

        internal AttributeUsageInfo(AttributeTargets validTargets, bool allowMultiple, bool inherited)
        {
            // NOTE: VB allows AttributeUsageAttribute with no valid target, i.e. <AttributeUsageAttribute(0)>, and doesn't generate any diagnostics.
            // We use use PackedAttributeUsage.Initialized field to differentiate between uninitialized AttributeUsageInfo and initialized AttributeUsageInfo with no valid targets.
            flags = (PackedAttributeUsage)validTargets | PackedAttributeUsage.Initialized;
            
            if (allowMultiple)
            {
                flags |= PackedAttributeUsage.AllowMultiple;
            }

            if (inherited)
            {
                flags |= PackedAttributeUsage.Inherited;
            }
        }

		public AttributeUsageAttribute (AttributeTargets validOn)
		{
			valid_on = validOn;
		}

 public virtual string GetAttributeTargetName(AttributeTargets targets) {
   if (this.ErrorHandler == null) return "";
   return this.ErrorHandler.GetAttributeTargetName(targets);
 }

 public AttributeUsageAttribute(AttributeTargets validOn)
 {
     this.validOn = validOn;
 }

 public AttributeUsageAttribute(AttributeTargets validOn) { }

 public static CompilerError InvalidAttributeTarget(Node node, Type attrType, AttributeTargets validOn)
 {
     return new CompilerError("BCE0153", SafeLexicalInfo(node), attrType, validOn);
 }

 [System.Security.SecurityCritical]  // auto-generated
 private static void ParseAttributeUsageAttribute(
     ConstArray ca, out AttributeTargets targets, out bool inherited, out bool allowMultiple)
 {
     int _targets;
     _ParseAttributeUsageAttribute(ca.Signature, ca.Length, out _targets, out inherited, out allowMultiple);
     targets = (AttributeTargets)_targets;
 }

			public NonInheritedAttribute(Type type, string str, int i, AttributeTargets e):
				this(type, str)
			{
			}

		public AttributeUsageAttribute(AttributeTargets validOn) {
			Inherited = true;
			return;
		}

 public virtual string GetAttributeTargetName(AttributeTargets targets) {
   StringBuilder sb = new StringBuilder();
   if ((targets & AttributeTargets.Assembly) != 0 || (targets & AttributeTargets.Module) != 0)
     sb.Append("assembly");
   if ((targets & AttributeTargets.Constructor) != 0) {
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("constructor");
   }
   if ((targets & AttributeTargets.Event) != 0) {
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("event");
   }
   if ((targets & AttributeTargets.Field) != 0) {
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("field");
   }
   if ((targets & AttributeTargets.Method) != 0) {
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("method");
   }
   if ((targets & AttributeTargets.Parameter) != 0){
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("param");
   }
   if ((targets & AttributeTargets.Property) != 0){
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("property");
   }
   if ((targets & AttributeTargets.ReturnValue) != 0){
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("return");
   }
   if ((targets & AttributeTargets.Class) != 0 && (targets & AttributeTargets.Delegate) != 0 &&
     (targets & AttributeTargets.Enum) != 0 && (targets & AttributeTargets.Interface) != 0 && (targets & AttributeTargets.Struct) != 0){
     if (sb.Length > 0) sb.Append(", ");
     sb.Append("type");
   }else{
     if ((targets & AttributeTargets.Class) != 0){
       if (sb.Length > 0) sb.Append(", ");
       sb.Append("class");
     }
     if ((targets & AttributeTargets.Delegate) != 0){
       if (sb.Length > 0) sb.Append(", ");
       sb.Append("delegate");
     }
     if ((targets & AttributeTargets.Enum) != 0){
       if (sb.Length > 0) sb.Append(", ");
       sb.Append("enum");
     }
     if ((targets & AttributeTargets.Interface) != 0){
       if (sb.Length > 0) sb.Append(", ");
       sb.Append("interface");
     }
     if ((targets & AttributeTargets.Struct) != 0){
       if (sb.Length > 0) sb.Append(", ");
       sb.Append("struct");
     }
   }
   return sb.ToString();
 }

 internal AttributeUsageAttribute(AttributeTargets validOn, bool allowMultiple, bool inherited)
 {
     m_attributeTarget = validOn;
     m_allowMultiple = allowMultiple;
     m_inherited = inherited;
 }

 public AttributeUsageAttribute(AttributeTargets validOn)
 {
     _attributeTarget = validOn;
     _inherited = true;
 }

		private static bool IsValid(AttributeTargets target, AttributeTargets validAttributeTargets)
		{
			return target == (validAttributeTargets & target);
		}