public override bool Include(ICustomAttribute attribute)
        {
            if (_attributeDocIds.Contains(attribute.DocId()))
                return false;

            return base.Include(attribute);
        }

 public virtual void PrintAttribute(IReference target, ICustomAttribute attribute, bool newLine, string targetType) {
   this.sourceEmitterOutput.Write("[", newLine);
   if (targetType != null) {
     this.sourceEmitterOutput.Write(targetType);
     this.sourceEmitterOutput.Write(": ");
   }
   this.PrintTypeReferenceName(attribute.Constructor.ContainingType);
   if (attribute.NumberOfNamedArguments > 0 || IteratorHelper.EnumerableIsNotEmpty(attribute.Arguments)) {
     this.sourceEmitterOutput.Write("(");
     bool first = true;
     foreach (var argument in attribute.Arguments) {
       if (first)
         first = false;
       else
         this.sourceEmitterOutput.Write(", ");
       this.Traverse(argument);
     }
     foreach (var namedArgument in attribute.NamedArguments) {
       if (first)
         first = false;
       else
         this.sourceEmitterOutput.Write(", ");
       this.Traverse(namedArgument);
     }
     this.sourceEmitterOutput.Write(")");
   }
   this.sourceEmitterOutput.Write("]");
   if (newLine) this.sourceEmitterOutput.WriteLine("");
 }

        /// <summary>
        /// Creates a new instance of the class.
        /// </summary>
        /// <param name="type">The attribute type.</param>
        /// <param name="attribute">The CCI attribute.</param>
        internal ScriptAttribute(ICustomAttribute attribute)
        {
            if (attribute == null)
                throw new InvalidOperationException();

            var typeRef = attribute.Type as INamedTypeReference;

            if (typeRef == null)
            {
                throw new InvalidOperationException("Attribute type must be a named type.");
            }

            var type = ScriptDomain.CurrentDomain.ResolveType(typeRef);

            if (type == null)
            {
                throw new InvalidOperationException("Unable to resolve type for attribute: " + typeRef.Name);
            }

            _type = type;
            _cciAttribute = attribute;

            _arguments = _cciAttribute.Arguments
                .Select(a => GetConstantValue(a)).ToArray();

            _namedArgs = _cciAttribute.NamedArguments.ToDictionary(a =>
                a.ArgumentName.Value, a => GetConstantValue(a));
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="customAttributeData"></param>
 /// <returns></returns>
 public IEnumerable<ICustomAttribute> GetCustomAttributes(IList<CustomAttributeData> customAttributeData) {
   int n = customAttributeData.Count;
   ICustomAttribute[] customAttributes = new ICustomAttribute[n];
   for (int i = 0; i < n; i++)
     customAttributes[i] = this.GetCustomAttribute(customAttributeData[i]);
   return IteratorHelper.GetReadonly(customAttributes);
 }

        public virtual bool Include(ICustomAttribute attribute)
        {
            if (this.ExcludeAttributes)
                return false;

            // Always return the custom attributes if ExcludeAttributes is not set
            // the PublicOnly mainly concerns the types and members.
            return true;
        }

        public bool Include(ICustomAttribute attribute)
        {
            string typeId = attribute.DocId();
            string removeUsages = "RemoveUsages:" + typeId;

            if (_docIds.Contains(removeUsages))
                return false;

            return _docIds.Contains(typeId);
        }

		static string GetPropertyString (ICustomAttribute attribute, string name)
		{
			if (!attribute.HasProperties)
				return String.Empty;

			foreach (var namedArg in attribute.Properties) {
				if (namedArg.Name == name) {
					return (namedArg.Argument.Value as string);
				}
			}
			return String.Empty;
		}

		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;
		}

        public bool Include(ICustomAttribute attribute)
        {
            string typeId = attribute.DocId();
            string removeUsages = "RemoveUsages:" + typeId;

            // special case: attribute usage can be removed without removing 
            //               the attribute itself
            if (_docIds.Contains(removeUsages))
                return false;

            // include so long as it isn't in the exclude list.
            return !_docIds.Contains(typeId);
        }

        public IEnumerable<SyntaxToken> GetTokenList(ICustomAttribute attribute, int indentLevel = -1)
        {
            EnsureTokenWriter();

            _tokenizer.ClearTokens();

            if (indentLevel != -1)
                _tokenizer.IndentLevel = indentLevel;

            _tokenWriter.WriteAttribute(attribute);

            return _tokenizer.ToTokenList();
        }

        public string GetString(ICustomAttribute attribute, int indentLevel = -1)
        {
            EnsureStringWriter();

            _string.Clear();

            if (indentLevel != -1)
                _stringWriter.SyntaxtWriter.IndentLevel = indentLevel;

            _stringWriter.WriteAttribute(attribute);

            return _string.ToString();
        }

        /// <summary>
        /// Tries to find an attribue by name
        /// </summary>
        /// <param name="attributes"></param>
        /// <param name="attributeName"></param>
        /// <param name="attribute"></param>
        /// <returns></returns>
        public static bool TryGetAttributeByName(
            IEnumerable<ICustomAttribute> attributes,
            string attributeName,
            out ICustomAttribute attribute)
        {
            Contract.Requires(!String.IsNullOrEmpty(attributeName));
            Contract.Ensures(!Contract.Result<bool>() || Contract.ValueAtReturn(out attribute) != null);

            if (attributes == null) { attribute = null; return false; }
            foreach (var a in attributes)
            {
                if (AttributeMatchesByName(a, attributeName))
                {
                    attribute = a;
                    return true;
                }
            }
            attribute = null;
            return false;
        }

        public void WriteAttribute(ICustomAttribute attribute, string prefix = null, SecurityAction action = SecurityAction.ActionNil)
        {
            if (!string.IsNullOrEmpty(prefix))
            {
                Write(prefix);
                WriteSymbol(":");
            }
            WriteTypeName(attribute.Constructor.ContainingType, noSpace: true); // Should we strip Attribute from name?

            if (attribute.NumberOfNamedArguments > 0 || attribute.Arguments.Any() || action != SecurityAction.ActionNil)
            {
                WriteSymbol("(");
                bool first = true;

                if (action != SecurityAction.ActionNil)
                {
                    Write("System.Security.Permissions.SecurityAction." + action.ToString());
                    first = false;
                }

                foreach (IMetadataExpression arg in attribute.Arguments)
                {
                    if (!first) WriteSymbol(",", true);
                    WriteMetadataExpression(arg);
                    first = false;
                }

                foreach (IMetadataNamedArgument namedArg in attribute.NamedArguments)
                {
                    if (!first) WriteSymbol(",", true);
                    WriteIdentifier(namedArg.ArgumentName);
                    WriteSymbol("=");
                    WriteMetadataExpression(namedArg.ArgumentValue);
                    first = false;
                }
                WriteSymbol(")");
            }
        }

        public virtual bool Include(ICustomAttribute attribute)
        {
            if (this.ExcludeAttributes)
                return false;

            // Ignore attributes not visible outside the assembly
            var attributeDef = attribute.Type.GetDefinitionOrNull();
            if (attributeDef != null && !attributeDef.IsVisibleOutsideAssembly())
                return false;

            // Ignore attributes with typeof argument of a type invisible outside the assembly
            foreach(var arg in attribute.Arguments.OfType<IMetadataTypeOf>())
            {
                var typeDef = arg.TypeToGet.GetDefinitionOrNull();
                if (typeDef == null)
                    continue;

                if (!typeDef.IsVisibleOutsideAssembly())
                    return false;
            }

            return true;
        }

 public override void TraverseChildren(ICustomAttribute customAttribute) {
   // Different uses of custom attributes must print them directly based on context
   //base.TraverseChildren(customAttribute);
 }

 public override void Visit(ICustomAttribute attribute)
 {
     Visit(attribute.Type); // For some reason the base visitor doesn't visit the attribute type
     base.Visit(attribute);
 }

 /// <summary>
 /// Performs some computation with the given custom attribute.
 /// </summary>
 public void Visit(ICustomAttribute customAttribute)
 {
     if (customAttribute.Constructor is Dummy)
       this.ReportError(MetadataError.IncompleteNode, customAttribute, "Constructor");
     else if (customAttribute.Type is Dummy)
       this.ReportError(MetadataError.IncompleteNode, customAttribute, "Type");
     else {
       if (!TypeHelper.TypesAreEquivalent(customAttribute.Constructor.ContainingType, customAttribute.Type))
     this.ReportError(MetadataError.CustomAttributeTypeIsNotConstructorContainer, customAttribute);
       if (customAttribute.Constructor.ResolvedMethod != Dummy.Method) {
     if (!customAttribute.Constructor.ResolvedMethod.IsConstructor)
       this.ReportError(MetadataError.CustomAttributeConstructorIsBadReference, customAttribute);
     if (!IteratorHelper.EnumerableHasLength(customAttribute.Arguments, customAttribute.Constructor.ResolvedMethod.ParameterCount)) {
       if (this.validator.currentSecurityAttribute == null || customAttribute.Constructor.ResolvedMethod.ParameterCount != 1 ||
     IteratorHelper.EnumerableIsNotEmpty(customAttribute.Arguments))
     this.ReportError(MetadataError.EnumerationCountIsInconsistentWithCountProperty, customAttribute, "Arguments");
     }
     //TODO: check that args match the types of the construtor param
       }
     }
     if (!IteratorHelper.EnumerableHasLength(customAttribute.NamedArguments, customAttribute.NumberOfNamedArguments))
       this.ReportError(MetadataError.EnumerationCountIsInconsistentWithCountProperty, customAttribute, "NamedArguments");
     //TODO: check that named args match the types of the attribute field/property.
 }

 public virtual bool Include(ICustomAttribute attribute)
 {
     return true;
 }

 /// <summary>
 /// Performs some computation with the given custom attribute.
 /// </summary>
 public virtual void Visit(ICustomAttribute customAttribute)
 {
 }

 /// <summary>
 /// Traverses the children of the custom attribute.
 /// </summary>
 public virtual void TraverseChildren(ICustomAttribute customAttribute)
 {
     Contract.Requires(customAttribute != null);
       this.Traverse(customAttribute.Arguments);
       if (this.stopTraversal) return;
       this.Traverse(customAttribute.Constructor);
       if (this.stopTraversal) return;
       this.Traverse(customAttribute.NamedArguments);
 }