public ICompletionData CreateEventCreationCompletionData(string varName, IType delegateType, IEvent evt,
                                                          string parameterDefinition,
                                                          IUnresolvedMember currentMember,
                                                          IUnresolvedTypeDefinition currentType)
 {
     return new CompletionData(varName);
 }

		public void AddType (IUnresolvedTypeDefinition type, string shortType)
		{
			if (type == null || string.IsNullOrEmpty (shortType) || usedTypes.Contains (shortType))
				return;
			usedTypes.Add (shortType);
			result.Add (Factory.CreateTypeCompletionData (type, shortType));
		}

		public SuggestedHandlerCompletionData (Project project, CodeMemberMethod methodInfo, IType codeBehindClass, IUnresolvedTypeDefinition codeBehindClassPart)
		{
			this.project = project;
			this.methodInfo = methodInfo;
			this.codeBehindClass = codeBehindClass;
			this.codeBehindClassPart = codeBehindClassPart;
		}

		public DefaultUnresolvedField(IUnresolvedTypeDefinition declaringType, string name)
		{
			this.SymbolKind = SymbolKind.Field;
			this.DeclaringTypeDefinition = declaringType;
			this.Name = name;
			if (declaringType != null)
				this.UnresolvedFile = declaringType.UnresolvedFile;
		}

		public DefaultUnresolvedTypeDefinition(IUnresolvedTypeDefinition declaringTypeDefinition, string name)
		{
			this.SymbolKind = SymbolKind.TypeDefinition;
			this.DeclaringTypeDefinition = declaringTypeDefinition;
			this.namespaceName = declaringTypeDefinition.Namespace;
			this.Name = name;
			this.UnresolvedFile = declaringTypeDefinition.UnresolvedFile;
		}

		public DefaultUnresolvedEvent(IUnresolvedTypeDefinition declaringType, string name)
		{
			this.EntityType = EntityType.Event;
			this.DeclaringTypeDefinition = declaringType;
			this.Name = name;
			if (declaringType != null)
				this.ParsedFile = declaringType.ParsedFile;
		}

		public DefaultUnresolvedTypeDefinition(IUnresolvedTypeDefinition declaringTypeDefinition, string name)
		{
			this.EntityType = EntityType.TypeDefinition;
			this.DeclaringTypeDefinition = declaringTypeDefinition;
			this.namespaceName = declaringTypeDefinition.Namespace;
			this.Name = name;
			this.ParsedFile = declaringTypeDefinition.ParsedFile;
		}

		public DefaultUnresolvedMethod(IUnresolvedTypeDefinition declaringType, string name)
		{
			this.EntityType = EntityType.Method;
			this.DeclaringTypeDefinition = declaringType;
			this.Name = name;
			if (declaringType != null)
				this.UnresolvedFile = declaringType.UnresolvedFile;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="VB6UnresolvedMethod"/> class.
 /// </summary>
 /// <param name="method">The instance of <see cref="IVbMethod"/> that is the source of this entity.</param>
 /// <param name="file">The file that is the source of this entity.</param>
 /// <param name="typeReference">The <see cref="IUnresolvedTypeReference"/> that this member is a child of. May be null.</param>
 /// <param name="typeDefinition">The <see cref="IUnresolvedTypeDefinition"/> that this entity is a child of. May be null.</param>
 internal VB6UnresolvedMethod(IVbMethod method, IUnresolvedFile file, ITypeReference typeReference, IUnresolvedTypeDefinition typeDefinition)
     : base(method, file, typeReference, typeDefinition)
 {
     if (method == null)
     {
         throw new ArgumentNullException("method");
     }
 }

 public NewPartialCompletionData(int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember member)
 {
     DeclarationBeginningIndex = declarationBegin;
     Type = type;
     Member = member;
     // check this:
     DeclarationCategory = type.SymbolKind.ResolveDeclarationCategoryFromSymbolKind();
     SetDefaultText(member.Name);
 }

		public EventCreationCompletionData(string handlerName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret)
		{
			if (string.IsNullOrEmpty(handlerName)) {
				handlerName = (evt != null ? evt.Name : "Handle");
			}
			this.handlerName = handlerName;
			this.DisplayText = StringParser.Parse("${res:CSharpBinding.Refactoring.EventCreation.EventHandlerText}", new[] { new StringTagPair("HandlerName", handlerName) });
			this.delegateTypeReference = delegateType.ToTypeReference();
			this.isStatic = callingMember != null && callingMember.IsStatic;
		}

		public EventCreationCompletionData(string handlerName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret)
		{
			if (string.IsNullOrEmpty(handlerName)) {
				handlerName = (evt != null ? evt.Name : "Handle");
			}
			this.handlerName = handlerName;
			this.DisplayText = "<Create " + handlerName + ">";
			this.delegateTypeReference = delegateType.ToTypeReference();
			this.isStatic = callingMember != null && callingMember.IsStatic;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="VB6UnresolvedEntityBase"/> class.
        /// </summary>
        /// <param name="file">The file that is the source of this entity.</param>
        /// <param name="typeDefinition">The <see cref="IUnresolvedTypeDefinition"/> that this entity is a child of. May be null.</param>
        protected VB6UnresolvedEntityBase(IUnresolvedFile file, IUnresolvedTypeDefinition typeDefinition)
            : this()
        {
            this.UnresolvedFile = file;

            VB6UnresolvedFile vb6File = (VB6UnresolvedFile)file;
            this.VbpProject = vb6File.Project;

            this.DeclaringTypeDefinition = typeDefinition;
        }

            public EventCompletionData(string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
            {
                SetDefaultText(varName);
                DeclarationCategory = DeclarationCategory.Event;
                // what should we do with parameterDefinition???
                DelegateType = delegateType;
                CurrentMember = currentMember;
                CurrentType = currentType;

                //Description = currentMember
            }

 ContextActionViewModel MakeViewModel(IUnresolvedTypeDefinition entity)
 {
     var ambience = AmbienceService.GetCurrentAmbience();
     ambience.ConversionFlags = ConversionFlags.ShowDeclaringType | ConversionFlags.ShowTypeParameterList;
     return new ContextActionViewModel {
         Action = new GoToDomRegionAction(entity.Region),
         Image = IconService.GetImageSource(IconService.GetImageForFile(entity.Region.FileName)),
         Comment = string.Format("(in {0})", Path.GetDirectoryName(entity.Region.FileName)),
         ChildActions = null
     };
 }

		public NewOverrideCompletionData (CSharpCompletionTextEditorExtension ext, int declarationBegin, IUnresolvedTypeDefinition type, IMember member) : base (null)
		{
			this.ext = ext;
			this.type   = type;
			this.member = member;
			
			this.declarationBegin = declarationBegin;
			this.GenerateBody = true;
			this.Icon = member.GetStockIcon ();
			this.DisplayText = ambience.GetString (member, OutputFlags.IncludeParameters | OutputFlags.IncludeParameterName | OutputFlags.IncludeGenerics | OutputFlags.HideExtensionsParameter| OutputFlags.IncludeAccessor);
			this.CompletionText = member.EntityType == EntityType.Indexer ? "this" : member.Name;
		}

        public static Node AsTree
            ( IUnresolvedTypeDefinition topLevelTypeDefinition
            , IDocument document) {

            var retval = new Node()
                { ChildNodes = topLevelTypeDefinition.Members
                    .Select(m => new Node(m, document))
                , Location = QuickFix.ForNonBodyRegion
                    (topLevelTypeDefinition, document)};

            return retval;
        }

		public EventCreationCompletionData(string varName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret) : base(evt)
		{
			if (string.IsNullOrEmpty(varName)) {
				this.DisplayText = "Create handler for " + (evt != null ? evt.Name : "");
			}
			else {
				this.DisplayText = "Create handler for " + char.ToUpper(varName[0]) + varName.Substring(1) + (evt != null ? evt.Name : "");
			}
			
			this.DisplayText = "<" + this.DisplayText + ">";
			this.eventDefinition = evt;
			this.delegateType = delegateType;
		}

		public static ITypeDefinition GetDesignableClass(IUnresolvedFile parsedFile, ICompilation compilation, out IUnresolvedTypeDefinition primaryPart)
		{
			primaryPart = null;
			if (parsedFile == null)
				return null;
			foreach (var utd in parsedFile.TopLevelTypeDefinitions) {
				var td = utd.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).GetDefinition();
				if (IsDesignable(td)) {
					primaryPart = utd;
					return td;
				}
			}
			return null;
		}

		void AddEntityBookmarks(IUnresolvedTypeDefinition c, IDocument document)
		{
			if (c.IsSynthetic) return;
			if (!c.Region.IsEmpty) {
				bookmarks.Add(new EntityBookmark(c, document));
			}
			foreach (var innerClass in c.NestedTypes) {
				AddEntityBookmarks(innerClass, document);
			}
			foreach (var m in c.Members) {
				if (m.Region.IsEmpty || m.IsSynthetic) continue;
				bookmarks.Add(new EntityBookmark(m, document));
			}
		}