public void AddMember(IUnresolvedEntity entity, Mono.Cecil.MemberReference cecilObject)
			{
				rwLock.EnterWriteLock();
				try {
					uint token = cecilObject.MetadataToken.ToUInt32();
					metadataTokens[entity] = token;
					
					var cecilMethod = cecilObject as Mono.Cecil.MethodDefinition;
					if (cecilMethod != null) {
						IUnresolvedMethod method = (IUnresolvedMethod)entity;
						tokenToMethod[token] = method;
						if (cecilMethod.HasBody) {
							var locals = cecilMethod.Body.Variables;
							if (locals.Count > 0) {
								localVariableTypes[method] = locals.Select(v => typeRefLoader.ReadTypeReference(v.VariableType)).ToArray();
							}
							if (cecilMethod.RVA != 0) {
								// The method was loaded from image - we can free the memory for the body
								// because Cecil will re-initialize it on demand
								cecilMethod.Body = null;
							}
						}
					}
				} finally {
					rwLock.ExitWriteLock();
				}
			}

		public EntityBookmark(IUnresolvedEntity entity, IDocument document)
		{
			this.entity = entity;
			int lineNr = entity.Region.BeginLine;
			if (document != null && lineNr > 0 && lineNr < document.LineCount) {
				this.line = document.GetLineByNumber(lineNr);
			}
		}

		protected AbstractResolvedEntity(IUnresolvedEntity unresolved, ITypeResolveContext parentContext)
		{
			if (unresolved == null)
				throw new ArgumentNullException("unresolved");
			if (parentContext == null)
				throw new ArgumentNullException("parentContext");
			this.unresolved = unresolved;
			this.parentContext = parentContext;
			this.Attributes = unresolved.Attributes.CreateResolvedAttributes(parentContext);
		}

		string GetString (Ambience amb, IUnresolvedEntity x)
		{
			var ctx = new SimpleTypeResolveContext (Document.Compilation.MainAssembly);
			IEntity rx = null;
			if (x is IUnresolvedMember)
				rx = ((IUnresolvedMember)x).CreateResolved (ctx);
			
			if (tag is IUnresolvedFile)
				return amb.GetString (rx, OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters | OutputFlags.UseFullInnerTypeName | OutputFlags.ReformatDelegates);
			return amb.GetString (rx, OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters | OutputFlags.ReformatDelegates);
		}

        /// <summary>
        ///   Creates a new QuickFix representing the non-bodyRegion
        ///   of the given region. Can be used to create QuickFixes
        ///   for AST members. The resulting QuickFix will then
        ///   contain the name and type signature of the member.
        /// </summary>
        /// <example>
        ///   For the region containing a "public string GetText(...)
        ///   {return null}" this method will return a QuickFix whose
        ///   Text is "public string GetText(...) ". So the returned
        ///   Text contains the type signature and not the body.
        /// </example>
        public static QuickFix ForNonBodyRegion(IUnresolvedEntity entity, IDocument document)
        {
            var text = GetNonBodyRegion
                (entity.Region, document, entity.BodyRegion);

            return new QuickFix
                { FileName = entity.Region.FileName
                , Line     = entity.Region.BeginLine
                , Column   = entity.Region.BeginColumn
                , Text     = text};
        }

		MemberReference GetCecilObject(IUnresolvedEntity entity)
		{
			object cecilObj;
			if (unresolvedTypeSystemToCecilDict.TryGetValue(entity, out cecilObj)) {
				return cecilObj as MemberReference;
			} else {
				return null;
			}
		}

 void AddAttributes(PropertyInfo propertyDefinition, IUnresolvedEntity targetEntity)
 {
     AddCustomAttributes(propertyDefinition.CustomAttributes, targetEntity.Attributes);
 }

        static string GetFormattedReturnType(IUnresolvedEntity entity)
        {
            string returnSignature = string.Empty;
            var method = entity as AbstractUnresolvedMember;

            if (method != null && method.ReturnType.ToString () != "void") {
                returnSignature = string.Format (" : {0}", method.ReturnType);
            }

            return returnSignature;
        }

		/// <summary>
		/// Gets the CompletionImage instance for the specified entity.
		/// Returns null when no image is available for the entity type.
		/// </summary>
		public static CompletionImage GetCompletionImage(IUnresolvedEntity entity)
		{
			if (entity == null)
				throw new ArgumentNullException("entity");
			switch (entity.SymbolKind) {
                case SymbolKind.TypeDefinition:
					return GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic);
                case SymbolKind.Field:
					IUnresolvedField field = (IUnresolvedField)entity;
					if (field.IsConst) {
						if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
							return imageEnumValue;
						else
							return imageLiteral;
					}
					return field.IsReadOnly ? imageFieldReadOnly : imageField;
                case SymbolKind.Method:
					IUnresolvedMethod method = (IUnresolvedMethod)entity;
					return method.IsOverridable ? imageVirtualMethod : imageMethod;
                case SymbolKind.Property:
					return imageProperty;
                case SymbolKind.Indexer:
					return imageIndexer;
                case SymbolKind.Event:
					return imageEvent;
                case SymbolKind.Operator:
                case SymbolKind.Destructor:
					return imageOperator;
                case SymbolKind.Constructor:
					return imageConstructor;
				default:
					return null;
			}
		}

		ITreeNavigator SearchMember (IUnresolvedEntity member)
		{
			return SearchMember (GetIdString (member));
		}

		ITreeNavigator SearchMember (IUnresolvedEntity member, bool expandNode = true)
		{
			return SearchMember (GetIdString (member), expandNode);
		}

		static string GetGlobal (IUnresolvedEntity entity)
		{
			switch (entity.SymbolKind) {
			case SymbolKind.Field:
				var field = (IUnresolvedField)entity;
				return field.IsStatic && !field.IsConst ? "static-" : "";
			case SymbolKind.Method:
			case SymbolKind.Constructor:
			case SymbolKind.Destructor:
			case SymbolKind.Operator:
			case SymbolKind.Property:
			case SymbolKind.Indexer:
				return entity.IsStatic ? "static-" : "";
			}
			return "";
		}

			public uint GetMetadataToken(IUnresolvedEntity entity)
			{
				rwLock.EnterReadLock();
				try {
					return metadataTokens[entity];
				} finally {
					rwLock.ExitReadLock();
				}
			}

		static bool NeedsDocumentation (TextEditorData data, IUnresolvedEntity member)
		{
			int lineNr = member.Region.BeginLine - 1;
			DocumentLine line;
			do {
				line = data.Document.GetLine (lineNr--);
			} while (lineNr > 0 && data.Document.GetLineIndent (line).Length == line.Length);
			return !data.Document.GetTextAt (line).TrimStart ().StartsWith ("///", StringComparison.Ordinal);
		}

		/// <summary>
		/// Gets the CompletionImage instance for the specified entity.
		/// Returns null when no image is available for the entity type.
		/// </summary>
		public static CompletionImage GetCompletionImage(IUnresolvedEntity entity)
		{
			if (entity == null)
				throw new ArgumentNullException("entity");
			switch (entity.SymbolKind) {
				case SymbolKind.TypeDefinition:
					return GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic);
				case SymbolKind.Field:
					IUnresolvedField field = (IUnresolvedField)entity;
					if (field.IsConst) {
						if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
							return imageEnumValue;
						else
							return imageLiteral;
					}
					return field.IsReadOnly ? imageFieldReadOnly : imageField;
				case SymbolKind.Method:
					IUnresolvedMethod method = (IUnresolvedMethod)entity;
					// We cannot reliably detect extension methods in the unresolved type system (e.g. in VB we need to resolve an attribute),
					// but at least we can do it for C#:
					var defMethod = method as DefaultUnresolvedMethod;
					if (defMethod != null && defMethod.IsExtensionMethod)
						return imageExtensionMethod;
					return method.IsOverridable ? imageVirtualMethod : imageMethod;
				case SymbolKind.Property:
					return imageProperty;
				case SymbolKind.Indexer:
					return imageIndexer;
				case SymbolKind.Event:
					return imageEvent;
				case SymbolKind.Operator:
				case SymbolKind.Destructor:
					return imageOperator;
				case SymbolKind.Constructor:
					return imageConstructor;
				default:
					return null;
			}
		}

		static string GetAccess (IUnresolvedEntity entity)
		{
			switch (entity.Accessibility) {
				case Accessibility.None:
				return "";
				case Accessibility.Private:
				return "private-";
				case Accessibility.Public:
				return "";
				case Accessibility.Protected:
				return "protected-";
				case Accessibility.Internal:
				return "internal-";
				case Accessibility.ProtectedOrInternal:
				case Accessibility.ProtectedAndInternal:
				return "ProtectedOrInternal-";
				default:
				throw new ArgumentOutOfRangeException ();
			}
		}

        static string GetParameters(IUnresolvedEntity entity)
        {
            var info = string.Empty;

            var method = entity as DefaultUnresolvedMethod;
            if (method != null) {
                var typeInfo = method.Parameters.Select (p => p.Type.ToString ());
                info = string.Format ("({0})", string.Join (", ", typeInfo));
            }
            return info;
        }

		static string GetSource (IUnresolvedEntity entity)
		{
			switch (entity.SymbolKind) {
			case SymbolKind.TypeDefinition:
				var type = (IUnresolvedTypeDefinition)entity;
				switch (type.Kind) {
				case TypeKind.Class:
					return "class";
				case TypeKind.Interface:
					return "interface";
				case TypeKind.Struct:
					return "struct";
				case TypeKind.Delegate:
					return "delegate";
				case TypeKind.Enum:
					return "enum";
				}
				return "class";
			case SymbolKind.Field:
				return "field";
			case SymbolKind.Event:
				return "event";
			case SymbolKind.Method:
			case SymbolKind.Constructor:
			case SymbolKind.Destructor:
			case SymbolKind.Operator:
				return "method";
			case SymbolKind.Property:
			case SymbolKind.Indexer:
				return "property";
			}
			return "";
		}

		public static IImage GetIcon(IUnresolvedEntity entity)
		{
			return GetIImage(CompletionImage.GetImage(entity));
		}

		bool IsInsideType (IUnresolvedEntity currentType, TextLocation location)
		{
			var document = engine.document;
			
			int startOffset = document.GetOffset (currentType.Region.Begin);
			int endOffset = document.GetOffset (location);
			bool foundEndBracket = false;
		
			var bracketStack = new Stack<char> ();
		
			bool isInString = false, isInChar = false;
			bool isInLineComment = false, isInBlockComment = false;
			
			for (int i = startOffset; i < endOffset; i++) {
				char ch = document.GetCharAt (i);
				switch (ch) {
					case '(':
					case '[':
					case '{':
						if (!isInString && !isInChar && !isInLineComment && !isInBlockComment)
							bracketStack.Push (ch);
						break;
					case ')':
					case ']':
					case '}':
						if (!isInString && !isInChar && !isInLineComment && !isInBlockComment)
						if (bracketStack.Count > 0)
							bracketStack.Pop ();
						break;
					case '\r':
					case '\n':
						isInLineComment = false;
						break;
					case '/':
						if (isInBlockComment) {
							if (i > 0 && document.GetCharAt (i - 1) == '*') 
								isInBlockComment = false;
						} else if (!isInString && !isInChar && i + 1 < document.TextLength) {
							char nextChar = document.GetCharAt (i + 1);
							if (nextChar == '/')
								isInLineComment = true;
							if (!isInLineComment && nextChar == '*')
								isInBlockComment = true;
						}
						break;
					case '"':
						if (!(isInChar || isInLineComment || isInBlockComment)) 
							isInString = !isInString;
						break;
					case '\'':
						if (!(isInString || isInLineComment || isInBlockComment)) 
							isInChar = !isInChar;
						break;
					default :
						break;
					}
				}
			return bracketStack.Any (t => t == '{');
		}