protected static ModelV2.Visibility AdjustVisibilityForClassesInterfacesAndStructs(EntityDeclaration ed)
        {
            VisibilityMode mode = VisibilityMapper.Map(ed.Modifiers);
            mode = mode == [email protected] ? [email protected] : [email protected];

            return new ModelV2.Visibility(mode);
        }

 /// <summary>
 /// Appends node attributes.
 /// </summary>
 /// <param name="buffer">the buffer</param>
 /// <param name="node">the node</param>
 /// <param name="stack">the stack</param>
 /// <example>
 /// <code>
 ///     [XmlIgnore]
 ///     [ConditionalAttribute("CODE_ANALYSIS")]
 ///     int DoSomething();
 /// </code>
 /// </example>
 public static void AppendAttributes(StringBuilder buffer, EntityDeclaration node, int stack)
 {
     foreach (var attribute in node.Attributes)
     {
         buffer.AppendLine(attribute.ToString().Trim(), stack);
     }
 }

		static bool CheckBody(EntityDeclaration node)
		{
			var custom = node as CustomEventDeclaration;
			if (custom != null && !(IsValidBody (custom.AddAccessor.Body) || IsValidBody (custom.RemoveAccessor.Body)))
			    return false;
			if (node is PropertyDeclaration || node is IndexerDeclaration) {
				var setter = node.GetChildByRole(PropertyDeclaration.SetterRole);
				var getter = node.GetChildByRole(PropertyDeclaration.GetterRole);
				return IsValidBody(setter.Body) && IsValidBody(getter.Body);
			} 
			return IsValidBody(node.GetChildByRole(Roles.Body));
		}

		static bool IsObsolete (EntityDeclaration entity)
		{
			if (entity == null)
				return false;
			foreach (var section in entity.Attributes) {
				foreach (var attr in section.Attributes) {
					var attrText = attr.Type.GetText ();
					if (attrText == "Obsolete" || attrText == "ObsoleteAttribute" || attrText == "System.Obsolete" || attrText == "System.ObsoleteAttribute" )
						return true;
				}
			}
			return false;
		}

		static ThrowStatement ImplementStub (RefactoringContext context, EntityDeclaration newNode)
		{
			ThrowStatement throwStatement = null;
			if (newNode is PropertyDeclaration || newNode is IndexerDeclaration) {
				var setter = newNode.GetChildByRole(PropertyDeclaration.SetterRole);
				if (!setter.IsNull)
					setter.AddChild(CreateNotImplementedBody(context, out throwStatement), Roles.Body); 

				var getter = newNode.GetChildByRole(PropertyDeclaration.GetterRole);
				if (!getter.IsNull)
					getter.AddChild(CreateNotImplementedBody(context, out throwStatement), Roles.Body); 
			} else {
				newNode.AddChild(CreateNotImplementedBody(context, out throwStatement), Roles.Body); 
			}
			return throwStatement;
		}

        protected virtual bool TryGetAttribute(EntityDeclaration type, string attributeName, out NRAttribute attribute)
        {
            foreach (var i in type.Attributes)
            {
                foreach (var j in i.Attributes)
                {
                    if (j.Type.ToString() == attributeName)
                    {
                        attribute = j;
                        return true;
                    }

                    // FIXME: Will not try to get the attribute via Resolver.ResolveNode() (see above): it returns a
                    //        different type, without minimum information needed to make a full NRAttribute -fzm
                }
            }

            attribute = default(NRAttribute);
            return false;
        }

        protected virtual bool HasAttribute(EntityDeclaration type, string name)
        {
            foreach (var i in type.Attributes)
            {
                foreach (var j in i.Attributes)
                {
                    if (j.Type.ToString() == name)
                    {
                        return true;
                    }

                    var resolveResult = this.Resolver.ResolveNode(j, null);
                    if (resolveResult != null && resolveResult.Type != null && resolveResult.Type.FullName == (name + "Attribute"))
                    {
                        return true;
                    }
                }
            }

            return false;
        }

 void FixAttributesAndDocComment(EntityDeclaration entity)
 {
     var node = entity.FirstChild;
     while (node != null && node.Role == Roles.Comment) {
         node = node.GetNextSibling(NoWhitespacePredicate);
         FixIndentation(node);
     }
     if (entity.Attributes.Count > 0) {
         AstNode n = null;
         foreach (var attr in entity.Attributes.Skip (1)) {
             FixIndentation(attr);
             n = attr;
         }
         if (n != null) {
             FixIndentation(n.GetNextNode(NoWhitespacePredicate));
         } else {
             FixIndentation(entity.Attributes.First().GetNextNode(NoWhitespacePredicate));
         }
     }
 }

		internal static string GetCorrectFileName (MDRefactoringContext context, EntityDeclaration type)
		{
			if (type == null)
				return context.Document.FileName;
			return Path.Combine (Path.GetDirectoryName (context.Document.FileName), type.Name + Path.GetExtension (context.Document.FileName));
		}

 private void MaybeCompileAndAddMethodToType(JsClass jsClass, EntityDeclaration node, BlockStatement body, IMethod method, MethodScriptSemantics options)
 {
     if (options.GenerateCode) {
         var typeParamNames = options.IgnoreGenericArguments ? (IEnumerable<string>)new string[0] : method.TypeParameters.Select(tp => _namer.GetTypeParameterName(tp)).ToList();
         JsMethod jsMethod;
         if (method.IsAbstract) {
             jsMethod = new JsMethod(method, options.Name, typeParamNames, null);
         }
         else {
             var compiled = CompileMethod(node, body, method, options);
             jsMethod = new JsMethod(method, options.Name, typeParamNames, compiled);
         }
         AddCompiledMethodToType(jsClass, method, options, jsMethod);
     }
 }

 protected virtual bool HasScript(EntityDeclaration declaration)
 {
     return this.HasAttribute(declaration, Translator.Bridge_ASSEMBLY + ".Script");
 }

        private void AddMethod(bool ctor, EntityDeclaration methodDeclaration, AstNodeCollection<ParameterDeclaration> parameters)
        {
            CLRType t = m_clrTypes.Value.Last.Value;

            List<KeyValuePair<string, string>> args = parameters.Select(p =>
                                                        new KeyValuePair<string, string>(p.Name, p.Type.ToString())
                                                      )
                                                      .ToList();

            Method m = new Method(
                CheckFlag(methodDeclaration.Modifiers, Modifiers.Override),
                ctor,
                CheckFlag(methodDeclaration.Modifiers, Modifiers.Static),
                new Visibility(VisibilityMapper.Map(methodDeclaration.Modifiers)),
                CheckFlag(methodDeclaration.Modifiers, Modifiers.Virtual),
                methodDeclaration.Name,
                CheckFlag(methodDeclaration.Modifiers, Modifiers.Abstract),
                args,
                methodDeclaration.ReturnType.ToString()

            );

            t.Methods.Add(m);   // connect
        }

        public virtual string GetInline(EntityDeclaration method)
        {
            var attr = this.GetAttribute(method.Attributes, Bridge.Translator.Translator.Bridge_ASSEMBLY + ".Template");

            return attr != null && attr.Arguments.Count > 0 ? ((string)((PrimitiveExpression)attr.Arguments.First()).Value) : null;
        }

		string ConvertMember(EntityDeclaration entity)
		{
			return ConvertHelper(entity, (p,obj,w,opt) => p.GenerateCodeFromMember((CodeTypeMember)obj, w, opt));
		}

 protected bool MatchAttributesAndModifiers(EntityDeclaration o, PatternMatching.Match match)
 {
     return (this.Modifiers == Modifiers.Any || this.Modifiers == o.Modifiers) && this.Attributes.DoMatch (o.Attributes, match);
 }

		static AstNode WrapInType(IUnresolvedTypeDefinition entity, EntityDeclaration decl)
		{
			if (entity == null)
				return decl;
			// Wrap decl in TypeDeclaration
			decl = new TypeDeclaration {
				ClassType = GetClassType(entity),
				Modifiers = Modifiers.Partial,
				Name = entity.Name,
				Members = { decl }
			};
			if (entity.DeclaringTypeDefinition != null) {
				// Handle nested types
				return WrapInType(entity.DeclaringTypeDefinition, decl);
			} 
			if (string.IsNullOrEmpty(entity.Namespace))
				return decl;
			return new NamespaceDeclaration(entity.Namespace) {
				Members = {
					decl
				}
			};
		}

		void UpdateMembers(EntityDeclaration baseDeclaration, EntityDeclaration declaration)
		{
			if (declaration.Modifiers.HasFlag(Modifiers.Static)) {
				declaration.Modifiers |= Modifiers.New;
			} else {
				declaration.Modifiers |= Modifiers.Override;
				baseDeclaration.Modifiers |= Modifiers.Virtual;
			}
		}

 public NamespacedEntityDeclaration(string @namespace, EntityDeclaration entityDeclaration)
 {
     Namespace = @namespace;
     EntityDeclaration = entityDeclaration;
 }

		void UpdatePath (object sender, Mono.TextEditor.DocumentLocationEventArgs e)
		{
			var parsedDocument = Document.ParsedDocument;
			if (parsedDocument == null || parsedDocument.ParsedFile == null)
				return;
			amb = new AstAmbience (document.GetFormattingOptions ());
			
			var unit = parsedDocument.GetAst<SyntaxTree> ();
			if (unit == null)
				return;

			var loc = Document.Editor.Caret.Location;

			var curType = (EntityDeclaration)unit.GetNodeAt (loc, n => n is TypeDeclaration || n is DelegateDeclaration);
			var curMember = unit.GetNodeAt<EntityDeclaration> (loc);
			if (curType == curMember)
				curMember = null;
			if (isPathSet && curType == lastType && lastMember == curMember)
				return;

			var curTypeMakeup = GetEntityMarkup (curType);
			var curMemberMarkup = GetEntityMarkup (curMember);
			if (isPathSet && curType != null && lastType != null && curType.StartLocation == lastType.StartLocation && curTypeMakeup == lastTypeMarkup &&
			    curMember != null && lastMember != null && curMember.StartLocation == lastMember.StartLocation && curMemberMarkup == lastMemberMarkup)
				return;

			lastType = curType;
			lastTypeMarkup = curTypeMakeup;

			lastMember = curMember;
			lastMemberMarkup = curMemberMarkup;

			if (curType == null) {
				if (CurrentPath != null && CurrentPath.Length == 1 && CurrentPath [0].Tag is IUnresolvedFile)
					return;
				var prevPath = CurrentPath;
				CurrentPath = new PathEntry[] { new PathEntry (GettextCatalog.GetString ("No selection")) { Tag = unit } };
				OnPathChanged (new DocumentPathChangedEventArgs (prevPath));	
				return;
			}
			
			//	ThreadPool.QueueUserWorkItem (delegate {
			var result = new List<PathEntry> ();

			if (curType != null) {
				var type = curType;
				while (type != null) {
					var declaringType = type.Parent as TypeDeclaration;
					result.Insert (0, new PathEntry (ImageService.GetPixbuf (type.GetStockIcon (false), Gtk.IconSize.Menu), GetEntityMarkup (type)) { Tag = (AstNode)declaringType ?? unit });
					type = declaringType;
				}
			}
				
			if (curMember != null) {
				result.Add (new PathEntry (ImageService.GetPixbuf (curMember.GetStockIcon (true), Gtk.IconSize.Menu), curMemberMarkup) { Tag = curMember });
				if (curMember is Accessor) {
					var parent = curMember.Parent as EntityDeclaration;
					if (parent != null)
						result.Insert (result.Count - 1, new PathEntry (ImageService.GetPixbuf (parent.GetStockIcon (true), Gtk.IconSize.Menu), GetEntityMarkup (parent)) { Tag = parent });
				}
			}
				
			var entry = GetRegionEntry (parsedDocument, loc);
			if (entry != null)
				result.Add (entry);
				
			PathEntry noSelection = null;
			if (curType == null) {
				noSelection = new PathEntry (GettextCatalog.GetString ("No selection")) { Tag = unit };
			} else if (curMember == null && !(curType is DelegateDeclaration)) { 
				noSelection = new PathEntry (GettextCatalog.GetString ("No selection")) { Tag = curType };
			}

			if (noSelection != null) 
				result.Add (noSelection);

			var prev = CurrentPath;
			if (prev != null && prev.Length == result.Count) {
				bool equals = true;
				for (int i = 0; i < prev.Length; i++) {
					if (prev [i].Markup != result [i].Markup) {
						equals = false;
						break;
					}
				}
				if (equals)
					return;
			}
			//		Gtk.Application.Invoke (delegate {
			CurrentPath = result.ToArray ();
			OnPathChanged (new DocumentPathChangedEventArgs (prev));	
			//		});
			//	});
		}

        /// <summary>
        ///   Inserts the given EntityDeclaration with the given
        ///   script at the end of the type declaration under the
        ///   cursor (e.g. class / struct).
        /// </summary>
        /// <remarks>
        ///   Alters the given script. Returns its CurrentDocument
        ///   property. Alters the given memberDeclaration, adding
        ///   Modifiers.Override to its Modifiers as well as removing
        ///   Modifiers.Virtual.
        /// </remarks>
        IDocument runOverrideTargetWorker
            ( Request                     request
            , OmniSharpRefactoringContext refactoringContext
            , ParsedResult                parsedContent
            , EntityDeclaration           memberDeclaration
            , OmniSharpScript             script) {

            // Add override flag
            memberDeclaration.Modifiers |= Modifiers.Override;
            // Remove virtual flag
            memberDeclaration.Modifiers &= ~ Modifiers.Virtual;

            // The current type declaration, e.g. class, struct..
            var typeDeclaration = parsedContent.SyntaxTree.GetNodeAt
                ( refactoringContext.Location
                , n => n.NodeType == NodeType.TypeDeclaration);

            // Even empty classes have nodes, so this works
            var lastNode =
                typeDeclaration.Children.Last();

            script.InsertBefore
                ( node    : lastNode
                , newNode : memberDeclaration);
            script.FormatText(memberDeclaration);

            return script.CurrentDocument;
        }