static void AddParameterList(CSharpTextEditorCompletion.CompletionDataCollector col, IEnumerable <IParameter> parameters)
        {
            foreach (IParameter p in parameters)
            {
                col.Add(p);
//				completionList.Add (p.Name, "md-literal");
            }
        }
        void AddContentsFromClassAndMembers(ExpressionContext context, CSharpTextEditorCompletion.CompletionDataCollector col)
        {
            IMethod method = callingMember as IMethod;

            if (method != null && method.Parameters != null)
            {
                AddParameterList(col, method.Parameters);
            }
            IProperty property = callingMember as IProperty;

            if (property != null && property.Parameters != null)
            {
                AddParameterList(col, property.Parameters);
            }
            if (CallingType == null)
            {
                return;
            }

            AddContentsFromOuterClass(CallingType, context, col);
            IType callingType = CallingType is InstantiatedType ? ((InstantiatedType)CallingType).UninstantiatedType : CallingType;

            //bool isInStatic = CallingMember != null ? CallingMember.IsStatic : false;

            if (CallingMember == null || !CallingMember.IsStatic)
            {
                foreach (TypeParameter parameter in callingType.TypeParameters)
                {
                    col.Add(parameter.Name, "md-literal");
                }
            }

            if (context != ExpressionContext.TypeDeclaration && CallingMember != null)
            {
                bool includeProtected = DomType.IncludeProtected(dom, CallingType, CallingMember.DeclaringType);
                foreach (IType type in dom.GetInheritanceTree(CallingType))
                {
                    foreach (IMember member in type.Members)
                    {
                        if (!(member is IType) && CallingMember.IsStatic && !(member.IsStatic || member.IsConst))
                        {
                            continue;
                        }
                        if (member.IsAccessibleFrom(dom, CallingType, CallingMember, includeProtected))
                        {
                            if (context.FilterEntry(member))
                            {
                                continue;
                            }
                            col.Add(member);
                        }
                    }
                }
            }
        }
 void AddContentsFromOuterClass(IType outer, ExpressionContext context, CSharpTextEditorCompletion.CompletionDataCollector col)
 {
     if (outer == null)
     {
         return;
     }
     foreach (IMember member in outer.Members)
     {
         if (member is IType || member.IsStatic || member.IsConst)
         {
             col.Add(member);
         }
     }
     AddContentsFromOuterClass(outer.DeclaringType, context, col);
 }
        public CSharpTextEditorCompletion.CompletionDataCollector AddAccessibleCodeCompletionData(ExpressionContext context, CSharpTextEditorCompletion.CompletionDataCollector col)
        {
            if (context != ExpressionContext.Global && context != ExpressionContext.TypeName)
            {
                AddContentsFromClassAndMembers(context, col);

                if (lookupTableVisitor != null && lookupTableVisitor.Variables != null)
                {
//					int callingMemberline = CallingMember != null ? CallingMember.Location.Line : 0;
                    // local variables could be outside members (LINQ initializers)
                    foreach (KeyValuePair <string, List <LocalLookupVariable> > pair in lookupTableVisitor.Variables)
                    {
                        if (pair.Value != null && pair.Value.Count > 0)
                        {
                            foreach (LocalLookupVariable v in pair.Value)
                            {
                                DomLocation varStartPos = new DomLocation(lookupVariableLine + v.StartPos.Line, v.StartPos.Column - 1);
                                DomLocation varEndPos   = new DomLocation(lookupVariableLine + v.EndPos.Line, v.EndPos.Column - 1);
                                if (varStartPos > this.resolvePosition || (!v.EndPos.IsEmpty && varEndPos < this.resolvePosition))
                                {
                                    continue;
                                }
                                col.Add(new LocalVariable(CallingMember, pair.Key, ConvertTypeReference(v.TypeRef), DomRegion.Empty));
                            }
                        }
                    }
                }

                if (CallingMember is IProperty)
                {
                    IProperty property = (IProperty)callingMember;
                    if (property.HasSet && editor != null && property.SetRegion.Contains(resolvePosition.Line, editor.CursorColumn))
                    {
                        col.Add("value");
                    }
                }

                if (CallingMember is IEvent)
                {
                    col.Add("value");
                }
            }

            List <string> namespaceList = new List <string> ();

            namespaceList.Add("");

            List <string> namespaceDeclList = new List <string> ();

            namespaceDeclList.Add("");
            if (unit != null)
            {
                foreach (IUsing u in unit.Usings)
                {
                    foreach (string alias in u.Aliases.Keys)
                    {
                        col.Add(alias);
                    }
                    if (u.Namespaces == null)
                    {
                        continue;
                    }
                    bool isNamespaceDecl = u.IsFromNamespace && u.Region.Contains(this.resolvePosition);
                    if (u.IsFromNamespace && !isNamespaceDecl)
                    {
                        continue;
                    }
                    foreach (string ns in u.Namespaces)
                    {
                        namespaceList.Add(ns);
                        if (isNamespaceDecl)
                        {
                            namespaceDeclList.Add(ns);
                        }
                    }
                }

                foreach (object o in dom.GetNamespaceContents(namespaceList, true, true))
                {
                    if (context.FilterEntry(o))
                    {
                        continue;
                    }
                    if (o is Namespace)
                    {
                        Namespace ns   = o as Namespace;
                        bool      skip = true;
                        foreach (string str in namespaceDeclList)
                        {
                            if (dom.NamespaceExists(str.Length > 0 ? str + "." + ns.Name : ns.Name))
                            {
                                skip = false;
                                break;
                            }
                        }
                        if (skip)
                        {
                            continue;
                        }
                    }

                    //IMember member = o as IMember;
                    //if (member != null && completionList.Find (member.Name) != null)
                    //	continue;
                    if (context == ExpressionContext.Attribute)
                    {
                        IType t = o as IType;
                        if (t != null && !t.IsBaseType(attributeType))
                        {
                            continue;
                        }
                    }
                    CompletionData data = col.Add(o);
                    if (data != null && context == ExpressionContext.Attribute && data.CompletionText != null && data.CompletionText.EndsWith("Attribute"))
                    {
                        string newText = data.CompletionText.Substring(0, data.CompletionText.Length - "Attribute".Length);
                        data.SetText(newText);
                    }
                }
                CodeTemplateService.AddCompletionDataForMime("text/x-csharp", col.CompletionList);
            }
            return(col);
        }