public override void Visit(DTokenDeclaration td)
        {
            if (td.Token == DTokens.Incomplete)
            {
                if (handlesBaseClasses)
                {
                    MemberFilter vis;
                    if (handledClass.ClassType == DTokens.Interface)
                    {
                        vis = MemberFilter.Interfaces | MemberFilter.Templates;
                    }
                    else
                    {
                        vis = MemberFilter.Classes | MemberFilter.Interfaces | MemberFilter.Templates;
                    }

                    prv = new CtrlSpaceCompletionProvider(cdgen, handledClass, vis | MemberFilter.BlockKeywords);
                }
                else if (td.InnerDeclaration != null)
                {
                    prv = new MemberCompletionProvider(cdgen, td.InnerDeclaration, scopedBlock);
                }
                else
                {
                    prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, ShownKeywords);
                }

                halt = true;
            }
            else
            {
                base.Visit(td);
            }
        }
 public override void Visit(DebugSpecification s)
 {
     if (s.SpecifiedId == DTokens.IncompleteId)
     {
         prv  = new DebugSpecificationCompletionProvider(cdgen);
         halt = true;
     }
 }
 public override void Visit(TraitsExpression x)
 {
     if (x.Keyword == DTokens.IncompleteId)
     {
         prv  = new TraitsExpressionCompletionProvider(cdgen);
         halt = true;
     }
     else
     {
         base.Visit(x);
     }
 }
 public override void Visit(NewExpression x)
 {
     if (IsIncompleteDeclaration(x.Type))
     {
         halt = true;
         prv  = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, MemberFilter.Types | MemberFilter.TypeParameters);
     }
     else
     {
         base.Visit(x);
     }
 }
 public override void Visit(ScopeGuardStatement s)
 {
     if (s.GuardedScope == DTokens.IncompleteId)
     {
         prv  = new ScopeAttributeCompletionProvider(cdgen);
         halt = true;
     }
     else
     {
         base.Visit(s);
     }
 }
 public override void VisitAttribute(DebugCondition c)
 {
     if (c.DebugIdHash == DTokens.IncompleteIdHash)
     {
         halt = true;
         prv  = new DebugSpecificationCompletionProvider(cdgen);
     }
     else
     {
         base.VisitAttribute(c);
     }
 }
 public override void Visit(ModuleStatement s)
 {
     if (IsIncompleteDeclaration(s.ModuleName))
     {
         prv  = new ModuleStatementCompletionProvider(cdgen);
         halt = true;
     }
     else
     {
         base.Visit(s);
     }
 }
 public override void VisitAttribute(VersionCondition vis)
 {
     if (vis.VersionIdHash == DTokens.IncompleteIdHash)
     {
         halt = true;
         prv  = new VersionSpecificationCompletionProvider(cdgen);
     }
     else
     {
         base.VisitAttribute(vis);
     }
 }
        public override void Visit(ContinueStatement s)
        {
            if (s.IdentifierHash == DTokens.IncompleteIdHash)
            {
                prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, MemberFilter.Labels);

                halt = true;
            }
            else
            {
                base.Visit(s);
            }
        }
 public override void VisitImport(ImportStatement.Import i)
 {
     if (IsIncompleteDeclaration(i.ModuleIdentifier))
     {
         prv  = new ImportStatementCompletionProvider(cdgen, i);
         halt = true;
     }
     else
     {
         curImport = i;
         base.VisitImport(i);
     }
 }
 public override void Visit(AsmStatement.InstructionStatement s)
 {
     if (s.Operation == AsmStatement.InstructionStatement.OpCode.__UNKNOWN__)
     {
         prv             = new InlineAsmCompletionProvider(s, cdgen);
         scopedStatement = s;
         halt            = true;
     }
     else
     {
         base.Visit(s);
     }
 }
 public override void VisitAttribute(PragmaAttribute a)
 {
     if (a.Arguments != null &&
         a.Arguments.Length > 0 &&
         IsIncompleteExpression(a.Arguments[a.Arguments.Length - 1]))
     {
         prv  = new PragmaCompletionProvider(a, cdgen);
         halt = true;
     }
     else
     {
         base.VisitAttribute(a);
     }
 }
        public override void VisitAttribute(Modifier a)
        {
            string c;

            if (a.ContentHash == DTokens.IncompleteIdHash || ((c = a.LiteralContent as string) != null && c.EndsWith(DTokens.IncompleteId)))
            {
                prv  = new AttributeCompletionProvider(a, cdgen);
                halt = true;
            }
            else
            {
                base.VisitAttribute(a);
            }
        }
 public override void VisitImport(ImportStatement.ImportBinding i)
 {
     if (!halt)
     {
         if (IsIncompleteDeclaration(i.Symbol))
         {
             prv  = new SelectiveImportCompletionProvider(cdgen, curImport);
             halt = true;
         }
         else
         {
             base.VisitImport(i);
         }
     }
 }
        public override void Visit(GotoStatement s)
        {
            if (s.StmtType == GotoStatement.GotoStmtType.Identifier &&
                s.LabelIdentifierHash == DTokens.IncompleteIdHash)
            {
                prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, s, MemberFilter.Labels);

                scopedStatement = s;
                halt            = true;
            }
            else
            {
                base.Visit(s);
            }
        }
 public override void VisitAttribute(UserDeclarationAttribute a)
 {
     if (a.AttributeExpression != null &&
         a.AttributeExpression.Length > 0 &&
         IsIncompleteExpression(a.AttributeExpression[0]))
     {
         prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock,
                                               MemberFilter.BuiltInPropertyAttributes | MemberFilter.Methods | MemberFilter.Variables | MemberFilter.Types);
         halt = true;
     }
     else
     {
         base.VisitAttribute(a);
     }
 }
 public override void Visit(IdentifierDeclaration td)
 {
     if (td.IdHash == DTokens.IncompleteIdHash)
     {
         halt = true;
         if (td.InnerDeclaration != null)
         {
             prv = new MemberCompletionProvider(cdgen, td.InnerDeclaration, scopedBlock);
         }
     }
     else
     {
         base.Visit(td);
     }
 }
        public override void Visit(StructInitializer init)
        {
            if (initializedNode != null && init.MemberInitializers != null && init.MemberInitializers.Length != 0)
            {
                var lastMemberInit = init.MemberInitializers[init.MemberInitializers.Length - 1];
                if (lastMemberInit.MemberNameHash == DTokens.IncompleteIdHash)
                {
                    prv  = new StructInitializerCompletion(cdgen, initializedNode, init);
                    halt = true;
                    return;
                }
            }

            base.Visit(init);
        }
 public override void VisitDNode(DNode n)
 {
     if (n.NameHash == DTokens.IncompleteIdHash)
     {
         if (n.ContainsAttribute(DTokens.Override))
         {
             prv = new MethodOverrideCompletionProvider(n, cdgen);
         }
         else
         {
             explicitlyNoCompletion = true;
         }
         halt = true;
     }
     else
     {
         base.VisitDNode(n);
     }
 }
        public override void Visit(DVariable n)
        {
            if (n.NameHash == 0 && n.ContainsAttribute(DTokens.Override))
            {
                prv  = new MethodOverrideCompletionProvider(n, cdgen);
                halt = true;
                return;
            }

            if (n.IsAlias)
            {
                // alias |
                // alias id = |
                // NOT alias Type |
                if (IsIncompleteDeclaration(n.Type))
                {
                    prv  = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, MemberFilter.All | MemberFilter.BlockKeywords);
                    halt = true;
                    return;
                }
            }
            else if (n.Initializer != null)
            {
                initializedNode    = n;
                handlesInitializer = true;
                n.Initializer.Accept(this);
                handlesInitializer = false;
            }

            if (!halt)
            {
                VisitDNode(n);
            }

            // auto |
            if (!halt && n.NameHash == 0 &&
                (n.ContainsAttribute(DTokens.Auto) || DParser.ContainsStorageClass(n.Attributes) != Modifier.Empty))
            {
                halt = true;
                explicitlyNoCompletion = true;
            }
        }
 public override void Visit(IsExpression x)
 {
     // is(Type |
     if (x.TypeAliasIdentifierHash == DTokens.IncompleteIdHash &&
         x.TestedType != null &&
         !IsIncompleteDeclaration(x.TestedType))
     {
         halt = true;
         explicitlyNoCompletion = true;
     }
     else if (x.TypeSpecializationToken == DTokens.Incomplete)
     {
         prv  = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, MemberFilter.Types | MemberFilter.ExpressionKeywords | MemberFilter.StatementBlockKeywords);
         halt = true;
     }
     else
     {
         base.Visit(x);
     }
 }
 public override void Visit(TokenExpression e)
 {
     if (e.Token == DTokens.Incomplete)
     {
         halt = true;
         const MemberFilter BaseAsmFlags = MemberFilter.Classes | MemberFilter.StructsAndUnions | MemberFilter.Enums | MemberFilter.Methods | MemberFilter.TypeParameters | MemberFilter.Types | MemberFilter.Variables;
         if (scopedStatement is AsmStatement || scopedStatement is AsmStatement.InstructionStatement)
         {
             prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, BaseAsmFlags | MemberFilter.x86Registers | MemberFilter.x64Registers | MemberFilter.Labels);
         }
         else if (scopedStatement is AsmStatement.RawDataStatement)
         {
             prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, BaseAsmFlags | MemberFilter.Labels);
         }
         else /*if (handlesInitializer)*/                 // Why only in initializers?
         {
             prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, shownKeywords.Count == 0 ? MemberFilter.All | MemberFilter.ExpressionKeywords : shownKeywords.Peek());
         }
     }
 }
 public override void Visit(PostfixExpression_Access x)
 {
     if (IsIncompleteExpression(x.AccessExpression))
     {
         halt = true;
         if (x.PostfixForeExpression is TokenExpression && (x.PostfixForeExpression as TokenExpression).Token == DTokens.Dot)
         {
             // Handle module-scoped things:
             // When typing a dot without anything following, trigger completion and show types, methods and vars that are located in the module & import scope
             prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.TypeParameters);
         }
         else
         {
             prv = new MemberCompletionProvider(cdgen, x.PostfixForeExpression, scopedBlock);
         }
     }
     else
     {
         base.Visit(x);
     }
 }
        public override void Visit(DVariable n)
        {
            if (n.NameHash == 0 && n.ContainsAttribute(DTokens.Override))
            {
                prv  = new MethodOverrideCompletionProvider(n, cdgen);
                halt = true;
                return;
            }

            if (n.IsAlias)
            {
                // alias |
                // alias id = |
                // NOT alias Type |
                if (IsIncompleteDeclaration(n.Type))
                {
                    prv  = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, scopedStatement);
                    halt = true;
                }
            }
            else if (n.Initializer != null)
            {
                handlesInitializer = true;
                n.Initializer.Accept(this);
                handlesInitializer = false;
            }

            if (!halt)
            {
                VisitDNode(n);
            }

            // auto |
            if (!halt && n.NameHash == 0 && n.ContainsAttribute(DTokens.Auto))
            {
                halt = true;
                explicitlyNoCompletion = true;
            }
        }