public static void EnumChildren(ICompletionDataGenerator cdgen,ResolutionContext ctxt, IBlockNode block, bool isVarInstance,
			MemberFilter vis = MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.Enums, bool publicImports = false)
        {
            var scan = new MemberCompletionEnumeration(ctxt, cdgen) { isVarInst = isVarInstance };

            scan.ScanBlock(block, CodeLocation.Empty, vis, publicImports);
        }

        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;
        }

 public CtrlSpaceCompletionProvider(ICompletionDataGenerator cdg, IBlockNode b, IStatement stmt, MemberFilter vis = MemberFilter.All)
     : base(cdg)
 {
     this.curBlock = b;
     this.curStmt = stmt;
     visibleMembers = vis;
 }

        public void Set(IBlockNode b)
        {
            scopedBlock = b;
            Caret = CodeLocation.Empty;

            ConditionalCompilation.EnumConditions(DeclarationCondititons, b, ctxt, CodeLocation.Empty);
        }

 public MemberCompletionProvider(ICompletionDataGenerator cdg, ISyntaxRegion sr, IBlockNode b, IStatement stmt)
     : base(cdg)
 {
     AccessExpression = sr;
     ScopedBlock = b;
     ScopedStatement = stmt;
 }

        public ContextFrame(ResolutionContext ctxt, IBlockNode b, IStatement stmt = null)
        {
            this.ctxt = ctxt;
            declarationCondititons = new ConditionalCompilation.ConditionSet(ctxt.CompilationEnvironment);

            Set(b,stmt);
        }

		public void Set(IBlockNode b, CodeLocation caret)
		{
			scopedBlock = b;
			Caret = caret;
			
			ConditionalCompilation.EnumConditions(DeclarationCondititons, b, ctxt, caret); 
		}

		public static BracketSearchResult SearchBrackets(TextDocument doc, IEditorData ed, IBlockNode curBlock, IStatement stmt)
		{
			while (stmt != null)
			{
				if (stmt is IExpressionContainingStatement)
				{
					var ecs = (IExpressionContainingStatement)stmt;
					foreach (var x in ecs.SubExpressions)
					{
						SurroundingParenthesesExpression spe = null;
						var xx = x;
						while (xx is ContainerExpression)
						{
							if (xx is SurroundingParenthesesExpression)
								spe = (SurroundingParenthesesExpression)xx;

							var subX = ((ContainerExpression)xx).SubExpressions;
							if (subX != null && subX.Length != 0)
							{
								xx = null;
								foreach (var sx in subX)
									if (ed.CaretLocation > sx.Location && ed.CaretLocation < sx.EndLocation)
									{
										xx = sx as ContainerExpression;
										break;
									}
							}
						}

						if (spe != null)
							return new BracketSearchResult(
								doc.GetOffset(spe.Location.Line, spe.Location.Column), 1,
								doc.GetOffset(spe.EndLocation.Line, spe.EndLocation.Column) - 1, 1);
					}
				}

				if (stmt is BlockStatement)
					return new BracketSearchResult(
						doc.GetOffset(stmt.Location.Line, stmt.Location.Column), 1,
						doc.GetOffset(stmt.EndLocation.Line, stmt.EndLocation.Column) - 1, 1);
				stmt = stmt.Parent;
			}

			if (curBlock != null && ed.CaretLocation < curBlock.BlockStartLocation)
				curBlock = curBlock.Parent as IBlockNode;

			if (curBlock == null || curBlock is DModule)
				return null;

			//TODO: Meta blocks, everything that could contain parentheses
			return new BracketSearchResult(
				doc.GetOffset(curBlock.BlockStartLocation.Line, curBlock.BlockStartLocation.Column), 1,
				doc.GetOffset(curBlock.EndLocation.Line, curBlock.EndLocation.Column) - 1, 1);
		}

        public static void EnumAllAvailableMembers(ICompletionDataGenerator cdgen, IBlockNode ScopedBlock
			, IStatement ScopedStatement,
			CodeLocation Caret,
		    ParseCacheView CodeCache,
			MemberFilter VisibleMembers,
			ConditionalCompilationFlags compilationEnvironment = null)
        {
            var ctxt = ResolutionContext.Create(CodeCache, compilationEnvironment, ScopedBlock, ScopedStatement);

            var en = new MemberCompletionEnumeration(ctxt, cdgen) {isVarInst = true};

            en.IterateThroughScopeLayers(Caret, VisibleMembers);
        }

        public static IEnumerable<INode> EnumAllAvailableMembers(IBlockNode ScopedBlock
			, IStatement ScopedStatement,
			CodeLocation Caret,
			ParseCacheList CodeCache,
			MemberFilter VisibleMembers)
        {
            return EnumAllAvailableMembers(new ResolverContextStack(CodeCache,new ResolverContext
            {
                ScopedBlock = ScopedBlock,
                ScopedStatement = ScopedStatement
            }),
            Caret,
            VisibleMembers);
        }

        public static void EnumConditions(ConditionSet cs,IStatement stmt, IBlockNode block, ResolutionContext ctxt, CodeLocation caret)
        {
            var l = new MutableConditionFlagSet();
            cs.LocalFlags = l;

            // If the current scope is a dedicated block.. (so NOT in a method but probably in an initializer or other static statement)
            if(block is DBlockNode)
            {
                // If so, get all (scoping) declaration conditions in the current block
                // and add them to the condition list
                var mblocks = ((DBlockNode)block).GetMetaBlockStack(caret, false, true);

                if(mblocks!=null && mblocks.Length!=0)
                    foreach(var mb in mblocks)
                    {
                        var amd = mb as AttributeMetaDeclaration;
                        if(amd!=null && amd.AttributeOrCondition!=null && amd.AttributeOrCondition.Length!=0)
                            foreach(var attr in amd.AttributeOrCondition)
                                if(attr is DeclarationCondition)
                                    l.Add((DeclarationCondition)attr);
                    }
            }

            // Scan up the current statement when e.g. inside a method body
            while (stmt != null)
            {
                if (stmt is StatementCondition)
                    l.Add(((StatementCondition)stmt).Condition);
                stmt = stmt.Parent;
            }

            // Go up the block hierarchy and add all conditions that belong to the respective nodes
            while (block != null)
            {
                var dn = block as DNode;
                if (dn!=null)
                {
                    if(dn is DBlockNode)
                        GetDoneVersionDebugSpecs(cs, l, dn as DBlockNode, ctxt);
                    if(dn.Attributes!=null)
                        foreach (var attr in dn.Attributes)
                            if (attr is DeclarationCondition)
                                l.Add(((DeclarationCondition)attr));
                }

                block = block.Parent as IBlockNode;
            }
        }

        public void Set(IBlockNode b, IStatement stmt = null)
        {
            scopedBlock = b;
            scopedStmt = stmt;

            var c = CodeLocation.Empty; //TODO: Take the caret position if we're in the currently edited module and the scoped block is the module root(?)
            if(stmt == null)
            {
                if(b!=null)
                    c = b.BlockStartLocation;
            }
            else
                c = stmt.Location;

            ConditionalCompilation.EnumConditions(declarationCondititons, stmt, b, ctxt, c);
        }

		void CreateDeeperLevelCache(IBlockNode bn)
		{
			var dd = TypeCache[bn] = new Dictionary<int,INode>();

			// Set the parent to null to crawl through current level only. Imports/Mixins etc. will be handled though.
			var parentBackup = bn.Parent;
			bn.Parent = null;

			sharedCtxt.CurrentContext.Set(bn);
			foreach (var n in ItemEnumeration.EnumScopedBlockChildren(sharedCtxt, MemberFilter.Types))
			{
				if (n.NameHash != 0)
					dd[n.NameHash] = n;
			}

			bn.Parent = parentBackup;
		}

		public override void VisitChildren (IBlockNode block)
		{
			if (!halt)
				shownKeywords.Push(BlockMemberFilter);

			var en = block.GetEnumerator ();
			while (!halt && en.MoveNext ()) {
				if (en.Current.Location > ed.CaretLocation) {
					halt = true;
					return;
				}
				en.Current.Accept (this);
			}

			if (!halt)
				shownKeywords.Pop ();
		}

		void SearchResultsIn(IBlockNode block, string pattern, List<INode> results, int maxResults)
		{
			// Don't search in modules themselves!

			if (block.Children.Count == 0 || results.Count > maxResults)
				return;

			foreach (var n in block.Children) {
				if(!results.Contains(n) && n.Name.Contains(pattern))
					if(!results.Contains(n))
						results.Add(n);
				
				if(n is IBlockNode)
					SearchResultsIn(n as IBlockNode, pattern, results, maxResults);

				if (results.Count > maxResults)
					return;
			}
		}

		public void FinishUpdate()
		{
			if (!hasBegun)
				return;

			hasBegun = false;

			int lineDiff = Editor.Caret.Line - currentLine;
			int colDiff = Editor.Caret.Column - currentCol;

			while (currentBlock != null)
			{
				if (isBeforeBlockStart)
				{
					currentBlock.BlockStartLocation = new CodeLocation(
						currentBlock.BlockStartLocation.Column + (currentBlock.BlockStartLocation.Line == Editor.Caret.Line ? colDiff : 0),
						currentBlock.BlockStartLocation.Line + lineDiff);
					isBeforeBlockStart = false;
				}

				currentBlock.EndLocation = new CodeLocation(
						currentBlock.EndLocation.Column + (currentBlock.EndLocation.Line == Editor.Caret.Line ? colDiff : 0),
						currentBlock.EndLocation.Line + lineDiff);
				currentBlock = currentBlock.Parent as IBlockNode;
			}

			while (currentStmt != null)
			{
				if (isAtStmtStart)
				{
					isAtStmtStart = currentStmt.Parent != null && currentStmt.Location == currentStmt.Parent.Location;
					currentStmt.Location = new CodeLocation(
						currentStmt.Location.Column + colDiff,
						currentStmt.Location.Line + lineDiff);
				}

				currentStmt.EndLocation = new CodeLocation(
						currentStmt.EndLocation.Column + (currentStmt.EndLocation.Line == Editor.Caret.Line ? colDiff : 0),
						currentStmt.EndLocation.Line + lineDiff);
				currentStmt = currentStmt.Parent;
			}
		}

		public virtual void VisitChildren(IBlockNode block)
		{
			foreach (var n in block)
				n.Accept(this);
		}

        private static void HandleNewExpression_Ctor(NewExpression nex, IBlockNode curBlock, List<AbstractType> _ctors, AbstractType t)
        {
            var udt = t as TemplateIntermediateType;
            if (udt is ClassType || udt is StructType)
            {
                bool explicitCtorFound = false;
                var constructors = new List<DMethod>();

                //TODO: Mixed-in ctors? --> Convert to AbstractVisitor/use NameScan
                foreach (var member in udt.Definition)
                {
                    var dm = member as DMethod;

                    if (dm != null && dm.SpecialType == DMethod.MethodType.Constructor)
                    {
                        explicitCtorFound = true;
                        if (!dm.IsPublic)
                        {
                            var curNode = curBlock;
                            bool pass = false;
                            do
                            {
                                if (curNode == udt.Definition)
                                {
                                    pass = true;
                                    break;
                                }
                            }
                            while ((curNode = curNode.Parent as IBlockNode) != curNode);

                            if (!pass)
                                continue;
                        }

                        constructors.Add(dm);
                    }
                }

                if (constructors.Count == 0)
                {
                    if (explicitCtorFound)
                    {
                        // TODO: Somehow inform the user that the current class can't be instantiated
                    }
                    else
                    {
                        // Introduce default constructor
                        constructors.Add(new DMethod(DMethod.MethodType.Constructor)
                        {
                            Description = "Default constructor for " + udt.Name,
                            Parent = udt.Definition
                        });
                    }
                }

                // Wrapp all ctor members in MemberSymbols
                foreach (var ctor in constructors)
                    _ctors.Add(new MemberSymbol(ctor, t, nex.Type));
            }
        }

        static void HandleTemplateInstance(TemplateInstanceExpression tix,
			ArgumentsResolutionResult res,
			IEditorData Editor,
			ResolutionContext ctxt,
			IBlockNode curBlock,
			IEnumerable<AbstractType> resultBases = null)
        {
            res.IsTemplateInstanceArguments = true;

            res.MethodIdentifier = tix;
            res.ResolvedTypesOrMethods = ExpressionTypeEvaluation.GetOverloads(tix, ctxt, resultBases, false);

            if (tix.Arguments != null)
                res.CurrentlyTypedArgumentIndex = tix.Arguments.Length;
            else
                res.CurrentlyTypedArgumentIndex = 0;
        }

		private ParameterInsightResolution(IEditorData ed, ResolutionContext c, ArgumentsResolutionResult r, IBlockNode cs) {
			Editor = ed;
			ctxt = c;
			res = r;
			curScope = cs;
		}