public override bool VisitDeclaration(Declaration decl)
        {
            if (!base.VisitDeclaration(decl))
                return false;

            if (Driver.Options.IsCSharpGenerator)
            {
                // C# cannot have protected members in static classes.
                var @class = decl.Namespace as Class;
                if (    decl.Access == AccessSpecifier.Protected &&
                        decl.GenerationKind == GenerationKind.Generate &&
                        @class != null &&
                        @class.IsStatic)
                {
                    // By setting it to private it will appear
                    // as an internal in the final C# wrapper.
                    decl.Access = AccessSpecifier.Private;

                    // We need to explicity set the generation else the
                    // now private declaration will get filtered out later.
                    decl.GenerationKind = GenerationKind.Generate;
                }
            }

            return true;
        }

        public IntellisenseItem(Declaration dtt)
        {
            Overrides = new List<IntellisenseOverride>();
            Name = dtt.Name;
            Glyph = dtt.Glyph;

            StringBuilder docs = new StringBuilder();
            foreach (var element in dtt.DescriptionText.Item)
            {
                if (element.IsDataTipElement)
                {
                    var x = (DataTipElement.DataTipElement)element;
                    Documentation = x.Item1;
                }
                else if (element.IsDataTipElementGroup)
                {
                    foreach (var subElement in ((DataTipElement.DataTipElementGroup)element).Item)
                    {
                        docs.AppendLine(subElement.Item1);
                        Overrides.Add(new IntellisenseOverride
                        {
                            Name = subElement.Item1
                        });
                    }
                }
            }

            if (String.IsNullOrEmpty(Documentation))
            {
                Documentation = docs.ToString();
            }
        }

        public bool CheckDeclarationAccess(Declaration decl)
        {
            var generateNonPublicDecls = Driver.Options.IsCSharpGenerator;

            switch (decl.Access)
            {
                case AccessSpecifier.Public:
                    return true;
                case AccessSpecifier.Protected:
                    var @class = decl.Namespace as Class;
                    if (@class != null && @class.IsValueType)
                        return false;
                    return generateNonPublicDecls;
                case AccessSpecifier.Private:
                    var method = decl as Method;
                    var isOverride = false;
                    if (method != null && method.IsOverride)
                    {
                        var baseMethod = ((Class) method.Namespace).GetBaseMethod(method);
                        isOverride = baseMethod.IsGenerated;
                    }
                    return generateNonPublicDecls && (isOverride || decl.IsExplicitlyGenerated);
            }

            return true;
        }

    public void Add(Declaration d)
    {
        if (d == null)
            return;

        decls.Add (d);
    }

        public static AddSignatures GetMethod(Declaration dec)
        {
            switch (dec.PropertyName.Text.ToLowerInvariant())
            {
                case "margin":
                case "padding":
                case "border-width":
                case "outline-width":
                    return Margins;

                case "border-radius":
                    return Corners;

                case "border":
                    return Borders;

                case "font":
                    return Fonts;

                case "columns":
                    return Columns;
            }

            return null;
        }

 public GenericSetter(Token Source, Declaration Function, String MemberName, Node Object)
     : base(Source)
 {
     this.Function = Function;
     this.Object = Object;
     this.MemberName = MemberName;
 }

        public override bool VisitDeclaration(Declaration decl)
        {
            if (decl.CompleteDeclaration != null)
                return true;

            return !decl.IsIncomplete;
        }

 /// <summary>
 /// Initializes a new instance of the DocumentRoot class.
 /// </summary>
 /// <param name="document">
 /// The document that this element belongs to.
 /// </param>
 /// <param name="declaration">
 /// The declaration class for this element.
 /// </param>
 /// <param name="generated">
 /// Indicates whether the element contains generated code.
 /// </param>
 internal DocumentRoot(CsDocument document, Declaration declaration, bool generated)
     : base(document, null, ElementType.Root, Strings.DocumentRoot, null, null, declaration, false, generated)
 {
     Param.AssertNotNull(document, "document");
     Param.AssertNotNull(declaration, "declaration");
     Param.Ignore(generated);
 }

 public ExplicitIndexSetter(Token Source, Declaration Function, Node Object, Node Index)
     : base(Source)
 {
     this.Function = Function;
     this.Object = Object;
     this.Index = Index;
 }

        public override bool VisitDeclaration(Declaration decl)
        {
            if (AlreadyVisited(decl))
                return false;

            if (decl.GenerationKind == GenerationKind.None)
                return true;

            if (!CheckDeclarationAccess(decl))
            {
                Log.Debug("Decl '{0}' was ignored due to invalid access",
                    decl.Name);
                decl.GenerationKind = decl is Field ? GenerationKind.Internal : GenerationKind.None;
                return true;
            }

            if (decl.IsDependent)
            {
                decl.GenerationKind = decl is Field ? GenerationKind.Internal : GenerationKind.None;
                Log.Debug("Decl '{0}' was ignored due to dependent context",
                    decl.Name);
                return true;
            }

            return true;
        }

 public static void RenderDeclaration(StringBuilder sb, Declaration decl)
 {
     sb.AppendFormat("{0}:", decl.Name);
     RenderExpression(sb, decl.Expression);
     if (decl.Important)
         sb.Append(" !important");
 }

        public override bool VisitDeclaration(Declaration decl)
        {
            if (AlreadyVisited(decl))
                return false;

            return !decl.Ignore;
        }

        public override bool VisitDeclaration(Declaration decl)
        {
            if (AlreadyVisited(decl))
                return false;

            if (decl.ExplicityIgnored)
                return true;

            if (!CheckDeclarationAccess(decl))
            {
                Log.Debug("Decl '{0}' was ignored due to invalid access",
                    decl.Name);
                decl.ExplicityIgnored = true;
                return true;
            }

            if (decl.IsDependent)
            {
                decl.ExplicityIgnored = true;
                Log.Debug("Decl '{0}' was ignored due to dependent context",
                    decl.Name);
                return true;
            }

            return true;
        }

 private static bool IsSupportedStdType(Declaration declaration)
 {
     return declaration.Namespace != null &&
         declaration.TranslationUnit.IsSystemHeader &&
         IsNameSpaceStd(declaration.Namespace) &&
         supportedStdTypes.Contains(declaration.OriginalName);
 }

        public override bool VisitDeclaration(Declaration decl)
        {
            if (AlreadyVisited(decl))
                return false;

            return decl.IsGenerated;
        }

        public override bool VisitDeclaration(Declaration decl)
        {
            if (!base.VisitDeclaration(decl))
                return false;

            // Do not clean up namespace names since it can mess up with the
            // names of anonymous or the global namespace.
            if (decl is Namespace)
                return true;

            // types with empty names are assumed to be private
            if (decl is Class && string.IsNullOrWhiteSpace(decl.Name))
            {
                decl.Name = decl.Namespace.Name == "_" ? "__" : "_";
                decl.ExplicitlyIgnore();
                return true;
            }

            Function function = decl as Function;
            if ((function == null || !function.IsOperator) && !(decl is Enumeration))
                decl.Name = CheckName(decl.Name);

            StringHelpers.CleanupText(ref decl.DebugText);
            return true;
        }

 public Declaration Declare(Type type, string name)
 {
     _declarationCounter++;
     string declarationName = name ?? string.Format("$var{0}$", _declarationCounter);
     var declaration = new Declaration(type, declarationName, FullName);
     Add(declaration);
     return declaration;
 }

 private void IdentifyTopLevelDecl(Declaration decl)
 {
     if (decl is ClassDecl)
         IdentifyClass((ClassDecl) decl);
     else if (decl is LiteralModuleDecl) {
         var literalModule = (LiteralModuleDecl) decl;
         IdentifyModule(literalModule.ModuleDef);
     }
 }

        public void add(Declaration declaration)
        {
            // an identifier cannot be declared more than once in the same scope
            if (locals.ContainsKey(declaration.identifier)) {
                throw new ScopeException(declaration.identifier.row, declaration.identifier.col, "An identifier cannot be used twice within the same scope.");
            }

            locals.Add(declaration.identifier, declaration);
        }

 public void AddDeclaration(Declaration decl)
 {
     decl.IfStack = new List<string>(this.ifStack);
     if (!this.declarations.Any(d => DeclaratorsSame(d, decl)
             && IfStacksSame(d, decl)))
     {
         this.declarations.Add(decl);
     }
 }