/// <summary>
		/// Generates the completion data.
		/// </summary>
		/// <param name="alreadyCheckedCompletionContext">Set to <c>false</c> if you already ensured that completion can occur in the current editing context.</param>
		public static bool GenerateCompletionData(IEditorData editor, 
			ICompletionDataGenerator completionDataGen, char triggerChar, bool alreadyCheckedCompletionContext = false)
		{
			if(!alreadyCheckedCompletionContext && !IsCompletionAllowed(editor, triggerChar))
				return false;

			IBlockNode _b = null;
			bool inNonCode;

			var sr = FindCurrentCaretContext(editor, ref _b, out inNonCode);

			if (inNonCode)
				return false;

			if (_b == null || editor.CaretLocation > _b.EndLocation) {
				_b = editor.SyntaxTree;
			}

			var complVis = new CompletionProviderVisitor (completionDataGen, editor, triggerChar) { scopedBlock = _b };
			if (sr is INode)
				(sr as INode).Accept (complVis);
			else if (sr is IStatement)
				(sr as IStatement).Accept (complVis);
			else if (sr is IExpression)
				(sr as IExpression).Accept (complVis);

			if (complVis.GeneratedProvider == null)
				return false;

			complVis.GeneratedProvider.BuildCompletionData(editor, triggerChar);

			return true;
		}

		static bool IsCompletionAllowed(IEditorData Editor, char enteredChar)
		{/*'debug(', 'version(', 'pragma(' etc. shall trigger, but not 'foo('
			if (enteredChar == '(')
				return false;
			*/
			if (Editor.CaretOffset > 0)
			{
				if (Editor.CaretLocation.Line == 1 && Editor.ModuleCode.Length > 0 && Editor.ModuleCode[0] == '#')
					return false;

				if (enteredChar == '.' || enteredChar == '_')
				{
					// Don't complete on a double/multi-dot
					if (Editor.CaretOffset > 1 && Editor.ModuleCode[Editor.CaretOffset - 2] == enteredChar) 
						// ISSUE: When a dot was typed, off-1 is the dot position, 
						// if a letter was typed, off-1 is the char before the typed letter..
						return false;
				}
				// If typing a begun identifier, return immediately
				else if ((Lexer.IsIdentifierPart(enteredChar) || enteredChar == '\0') &&
					Lexer.IsIdentifierPart(Editor.ModuleCode[Editor.CaretOffset - 1]))
					return false;
			}

			return true;
		}

        public void Populate(IEditorData data)
        {
            m_data = data;

            if (data == null)
            {
                m_value = null;
                return;
            }

            m_populating = true;
            PopulateList();

            object attr = data.GetAttribute(m_definition.Attribute);
            IEditableObjectReference value = attr as IEditableObjectReference;

            if (value == null)
            {
                lstDropdown.Text = string.Empty;
                lstDropdown.IsEnabled = (attr == null);
            }
            else
            {
                lstDropdown.SelectedItem = value.Reference;
                lstDropdown.IsEnabled = !data.ReadOnly;
            }

            m_value = value;

            m_populating = false;
        }

		protected override void BuildCompletionDataInternal(IEditorData Editor, char enteredChar)
		{
			ed = Editor;
			ctxt = ResolutionContext.Create(Editor, false);

			AbstractType t = null;
			CodeCompletion.DoTimeoutableCompletionTask(CompletionDataGenerator,ctxt,() =>
			{
				try
				{
					ctxt.Push(Editor);
					if (AccessExpression is IExpression)
						t = ExpressionTypeEvaluation.EvaluateType(AccessExpression as IExpression, ctxt);
					else if (AccessExpression is ITypeDeclaration)
						t = TypeDeclarationResolver.ResolveSingle(AccessExpression as ITypeDeclaration, ctxt);
				}catch(Exception ex)
				{
					Logger.LogWarn("Error during member completion", ex);
				}
			});

			if (t == null) //TODO: Add after-space list creation when an unbound . (Dot) was entered which means to access the global scope
				return;

			t.Accept(this);
		}

		public static bool IsCompletionAllowed(IEditorData Editor, char enteredChar)
		{
			if (Editor.CaretOffset > 0)
			{
				if (Editor.CaretLocation.Line == 1 && Editor.ModuleCode.Length > 0 && Editor.ModuleCode[0] == '#')
					return false;

				if (enteredChar == '.' || enteredChar == '_')
				{
					// Don't complete on a double/multi-dot
					if (Editor.CaretOffset > 1 && Editor.ModuleCode[Editor.CaretOffset - 2] == enteredChar) 
						// ISSUE: When a dot was typed, off-1 is the dot position, 
						// if a letter was typed, off-1 is the char before the typed letter..
						return false;
				}
				// If typing a begun identifier, return immediately
				else if ((DTokens.IsIdentifierChar(enteredChar) || enteredChar == '\0') &&
					DTokens.IsIdentifierChar(Editor.ModuleCode[Editor.CaretOffset - 1]))
					return false;

				return !CaretContextAnalyzer.IsInCommentAreaOrString(Editor.ModuleCode, Editor.CaretOffset);
			}

			return true;
		}

 public void Populate(IEditorData data)
 {
     if (data == null) return;
     m_helper.StartPopulating();
     textBox.Text = m_helper.Populate(data);
     m_helper.FinishedPopulating();
 }

		protected override void BuildCompletionDataInternal(IEditorData Editor, char enteredChar)
		{
			if(Editor.ParseCache == null)
				return;

			string pack = null;

			if (imp.ModuleIdentifier != null && imp.ModuleIdentifier.InnerDeclaration != null)
			{
				pack = imp.ModuleIdentifier.InnerDeclaration.ToString();

				// Will occur after an initial dot  
				if (string.IsNullOrEmpty(pack))
					return;
			}

			foreach (var p in Editor.ParseCache.LookupPackage(Editor.SyntaxTree, pack))
			{
				if (p == null)
					continue;

				foreach (var kv_pack in p.Packages)
					CompletionDataGenerator.AddPackage(kv_pack.Value.Name);

				foreach (var kv_mod in p.Modules)
					CompletionDataGenerator.AddModule(kv_mod.Value);
			}
		}

        static string GetSelectedSymbolRoot(IEditorData edData)
        {
            var o = DResolver.GetScopedCodeObject(edData,null, DResolver.AstReparseOptions.AlsoParseBeyondCaret);

            if (o is ITypeDeclaration)
            {
                var rootType = ((ITypeDeclaration)o).InnerMost;

                if (rootType is IdentifierDeclaration)
                    return ((IdentifierDeclaration)rootType).Id;
                else if (rootType is TemplateInstanceExpression)
                    return ((TemplateInstanceExpression)rootType).TemplateIdentifier.Id;
            }
            else if (o is IExpression)
            {
                var curEx = (IExpression)o;

                while (curEx is PostfixExpression)
                    curEx = ((PostfixExpression)curEx).PostfixForeExpression;

                if (curEx is IdentifierExpression)
                    return ((IdentifierExpression)curEx).Value as string;
                else if (curEx is TemplateInstanceExpression)
                    return ((TemplateInstanceExpression)curEx).TemplateIdentifier.Id;
            }
            return null;
        }

 protected override void BuildCompletionDataInternal(IEditorData Editor, char enteredChar)
 {
     foreach (var kv in new Dictionary<string, string>{
         {"isArithmetic","If the arguments are all either types that are arithmetic types, or expressions that are typed as arithmetic types, then true is returned. Otherwise, false is returned. If there are no arguments, false is returned."},
         {"isFloating","Works like isArithmetic, except it's for floating point types (including imaginary and complex types)."},
         {"isIntegral","Works like isArithmetic, except it's for integral types (including character types)."},
         {"isScalar","Works like isArithmetic, except it's for scalar types."},
         {"isUnsigned","Works like isArithmetic, except it's for unsigned types."},
         {"isStaticArray","Works like isArithmetic, except it's for static array types."},
         {"isAssociativeArray","Works like isArithmetic, except it's for associative array types."},
         {"isAbstractClass","If the arguments are all either types that are abstract classes, or expressions that are typed as abstract classes, then true is returned. Otherwise, false is returned. If there are no arguments, false is returned."},
         {"isFinalClass","Works like isAbstractClass, except it's for final classes."},
         {"isVirtualFunction","The same as isVirtualMethod, except that final functions that don't override anything return true."},
         {"isVirtualMethod","Takes one argument. If that argument is a virtual function, true is returned, otherwise false. Final functions that don't override anything return false."},
         {"isAbstractFunction","Takes one argument. If that argument is an abstract function, true is returned, otherwise false."},
         {"isFinalFunction","Takes one argument. If that argument is a final function, true is returned, otherwise false."},
         {"isStaticFunction","Takes one argument. If that argument is a static function, meaning it has no context pointer, true is returned, otherwise false."},
         {"isRef","Takes one argument. If that argument is a declaration, true is returned if it is ref, otherwise false."},
         {"isOut","Takes one argument. If that argument is a declaration, true is returned if it is out, otherwise false."},
         {"isLazy","Takes one argument. If that argument is a declaration, true is returned if it is lazy, otherwise false."},
         {"hasMember","The first argument is a type that has members, or is an expression of a type that has members. The second argument is a string. If the string is a valid property of the type, true is returned, otherwise false."},
         {"identifier","Takes one argument, a symbol. Returns the identifier for that symbol as a string literal."},
         {"getMember","Takes two arguments, the second must be a string. The result is an expression formed from the first argument, followed by a ‘.’, followed by the second argument as an identifier."},
         {"getOverloads","The first argument is a class type or an expression of class type. The second argument is a string that matches the name of one of the functions of that class. The result is a tuple of all the overloads of that function."},
         {"getVirtualFunctions","The same as getVirtualMethods, except that final functions that do not override anything are included."},
         {"getVirtualMethods","The first argument is a class type or an expression of class type. The second argument is a string that matches the name of one of the functions of that class. The result is a tuple of the virtual overloads of that function. It does not include final functions that do not override anything."},
         {"parent","Takes a single argument which must evaluate to a symbol. The result is the symbol that is the parent of it."},
         {"classInstanceSize","Takes a single argument, which must evaluate to either a class type or an expression of class type. The result is of type size_t, and the value is the number of bytes in the runtime instance of the class type. It is based on the static type of a class, not the polymorphic type."},
         {"allMembers","Takes a single argument, which must evaluate to either a type or an expression of type. A tuple of string literals is returned, each of which is the name of a member of that type combined with all of the members of the base classes (if the type is a class). No name is repeated. Builtin properties are not included."},
         {"derivedMembers","Takes a single argument, which must evaluate to either a type or an expression of type. A tuple of string literals is returned, each of which is the name of a member of that type. No name is repeated. Base class member names are not included. Builtin properties are not included."},
         {"isSame","Takes two arguments and returns bool true if they are the same symbol, false if not."},
         {"compiles",@"Returns a bool true if all of the arguments compile (are semantically correct). The arguments can be symbols, types, or expressions that are syntactically correct. The arguments cannot be statements or declarations. If there are no arguments, the result is false."},
     })
         CompletionDataGenerator.AddTextItem(kv.Key, kv.Value);
 }

 public void Populate(IEditorData data)
 {
     if (data == null) return;
     m_helper.StartPopulating();
     if (m_dictionary != null)
     {
         string value = m_helper.Populate(data) ?? string.Empty;
         string dropdownValue;
         if (m_dictionary.TryGetValue(value, out dropdownValue))
         {
             lstDropdown.Text = dropdownValue;
         }
         else
         {
             if (lstDropdown.IsEditable)
             {
                 lstDropdown.Text = value;
             }
             else
             {
                 lstDropdown.Text = string.Empty;
             }
         }
     }
     else
     {
         lstDropdown.Text = m_helper.Populate(data);
     }
     lstDropdown.IsEnabled = m_helper.CanEdit(data) && !data.ReadOnly;
     m_helper.FinishedPopulating();
 }

        public static ISyntaxRegion FindCurrentCaretContext(IEditorData editor, 
			ref IBlockNode currentScope, 
			out IStatement currentStatement,
			out bool isInsideNonCodeSegment)
        {
            isInsideNonCodeSegment = false;
            currentStatement = null;

            if(currentScope == null)
                currentScope = DResolver.SearchBlockAt (editor.SyntaxTree, editor.CaretLocation, out currentStatement);

            if (currentScope == null)
                return null;

            BlockStatement blockStmt;
            // Always skip lambdas as they're too quirky for accurate scope calculation // ISSUE: May be other anon symbols too?
            var dm = currentScope as DMethod;
            if (dm != null && (dm.SpecialType & DMethod.MethodType.Lambda) != 0)
                currentScope = dm.Parent as IBlockNode;

            if (currentScope is DMethod &&
                (blockStmt = (currentScope as DMethod).GetSubBlockAt (editor.CaretLocation)) != null) {
                blockStmt.UpdateBlockPartly (editor, out isInsideNonCodeSegment);
                currentScope = DResolver.SearchBlockAt (currentScope, editor.CaretLocation, out currentStatement);
            }else {
                while (currentScope is DMethod)
                    currentScope = currentScope.Parent as IBlockNode;
                if (currentScope == null)
                    return null;

                (currentScope as DBlockNode).UpdateBlockPartly (editor, out isInsideNonCodeSegment);
                currentScope = DResolver.SearchBlockAt (currentScope, editor.CaretLocation, out currentStatement);
            }
            return currentScope;
        }

		protected override void BuildCompletionDataInternal(IEditorData Editor, char enteredChar)
		{
			var visibleMembers = MemberFilter.All;

			if(!GetVisibleMemberFilter(Editor, enteredChar, ref visibleMembers, ref curStmt))
				return;

			MemberCompletionEnumeration.EnumAllAvailableMembers(
					CompletionDataGenerator,
					curBlock,
					curStmt,
					Editor.CaretLocation,
					Editor.ParseCache,
					visibleMembers,
					new ConditionalCompilationFlags(Editor));

			//TODO: Split the keywords into such that are allowed within block statements and non-block statements
			// Insert typable keywords
			if (visibleMembers.HasFlag(MemberFilter.Keywords))
				foreach (var kv in DTokens.Keywords)
					CompletionDataGenerator.Add(kv.Key);

			else if (visibleMembers.HasFlag(MemberFilter.StructsAndUnions))
				foreach (var kv in DTokens.BasicTypes_Array)
					CompletionDataGenerator.Add(kv);
		}

        protected override void BuildCompletionDataInternal(IEditorData Editor, char enteredChar)
        {
            var dc = begunNode.Parent as DClassLike;

            if (dc == null || dc.ClassType != DTokens.Class)
                return;

            var classType = DResolver.ResolveClassOrInterface(dc, ResolutionContext.Create(Editor), null) as TemplateIntermediateType;

            if (classType == null)
                return;

            var typesToScan = new List<TemplateIntermediateType>();
            IterateThroughBaseClassesInterfaces(typesToScan, classType);

            foreach (var t in typesToScan)
            {
                foreach (var n in t.Definition)
                {
                    var dm = n as DMethod;
                    if (dm == null ||
                        dm.ContainsAttribute(DTokens.Final, DTokens.Private, DTokens.Static))
                        continue; //TODO: Other attributes?

                    CompletionDataGenerator.AddCodeGeneratingNodeItem(dm, GenerateOverridingMethodStub(dm, begunNode, !(t is InterfaceType)));
                }
            }
        }

		public CompletionProviderVisitor(ICompletionDataGenerator cdg, IEditorData ed, char enteredChar = '\0')
		{
			this.ed = ed;
			this.cdgen = cdg;
			this.triggerChar = enteredChar;
			this.shownKeywords.Push(BlockMemberFilter);
		}

        public void Populate(IEditorData data)
        {
            m_readOnly = data != null && data.ReadOnly;
            cmdAdd.Enabled = !m_readOnly;
            cmdAddType.Enabled = !m_readOnly;

            lstAttributes.Items.Clear();
            lstTypes.Items.Clear();
            m_inheritedTypeData.Clear();
            ClearListenedToAttributes();
            cmdDelete.Enabled = false;
            cmdOnChange.Enabled = false;
            cmdDeleteType.Enabled = false;
            ctlMultiControl.Visible = false;
            m_data = (IEditorDataExtendedAttributeInfo)data;

            if (data != null)
            {
                foreach (var type in m_data.GetInheritedTypes())
                {
                    m_inheritedTypeData.Add(type.AttributeName, type);
                    AddListItem(lstTypes, type, GetTypeDisplayString);
                }

                foreach (var attr in m_data.GetAttributeData())
                {
                    if (CanDisplayAttribute(attr.AttributeName, m_data.GetAttribute(attr.AttributeName), attr.Source != m_data.Name))
                    {
                        AddListItem(lstAttributes, attr, GetAttributeDisplayString);
                        ListenToAttribute(attr);
                    }
                }
            }
        }

        public void Populate(IEditorData data)
        {
            m_data = data;

            IEnumerable<string> elements = null;
            if (m_elementType == "object")
            {
                string parent = m_data == null ? null : m_data.Name;
                if (parent == "game") parent = null;
                elements = Controller.GetObjectNames(m_objectType, false, parent, true);
            }
            else
            {
                elements = Controller.GetElementNames(m_elementType, false);
            }

            Dictionary<string, string> listItems = new Dictionary<string, string>();

            foreach (var element in elements.Where(e => Filter(e)))
            {
                listItems.Add(element, Controller.GetDisplayName(element));
            }

            ctlListEditor.UpdateList(listItems);
        }

        public static TestCompletionDataGen TestCompletionListContents(IEditorData ed, INode[] itemWhiteList = null, INode[] itemBlackList = null, char trigger = '\0')
        {
            var gen = new TestCompletionDataGen (itemWhiteList, itemBlackList);
            Assert.That (CodeCompletion.GenerateCompletionData (ed, gen, trigger), Is.True);

            Assert.That (gen.HasRemainingItems, Is.False, "Some items were not enlisted!");
            return gen;
        }

 public void Populate(IEditorData data)
 {
     if (data == null) return;
     m_helper.StartPopulating();
     checkBox.IsChecked = m_helper.Populate(data);
     checkBox.IsEnabled = !data.ReadOnly && m_helper.CanEdit(data);
     m_helper.FinishedPopulating();
 }

 public void ApplyFrom(IEditorData data)
 {
     ModuleCode = data.ModuleCode;
     CaretLocation = data.CaretLocation;
     CaretOffset = data.CaretOffset;
     SyntaxTree = data.SyntaxTree;
     ParseCache = data.ParseCache;
 }

 public void Populate(IEditorData data)
 {
     m_data = data;
     if (data == null) return;
     m_helper.StartPopulating();
     ctlNumber.Value = m_helper.Populate(data);
     ctlNumber.IsEnabled = m_helper.CanEdit(data) && !data.ReadOnly;
     m_helper.FinishedPopulating();
 }