public ArrayList GetCompletionItems(string subNamespace) { ArrayList items = projectContent.GetNamespaceContents(subNamespace); if (String.IsNullOrEmpty(subNamespace)) { AddStandardPythonModules(items); } return(items); }
public static void AddUsing(ArrayList result, IUsing u, IProjectContent projectContent) { if (u == null) { return; } bool importNamespaces = projectContent.Language.ImportNamespaces; bool importClasses = projectContent.Language.CanImportClasses; foreach (string name in u.Usings) { if (importClasses) { IClass c = projectContent.GetClass(name, 0); if (c != null) { ArrayList members = new ArrayList(); IReturnType t = c.DefaultReturnType; members.AddRange(t.GetMethods()); members.AddRange(t.GetFields()); members.AddRange(t.GetEvents()); members.AddRange(t.GetProperties()); foreach (IMember m in members) { if (m.IsStatic && m.IsPublic) { result.Add(m); } } continue; } } if (importNamespaces) { string newName = null; if (projectContent.DefaultImports != null) { newName = projectContent.DefaultImports.SearchNamespace(name); } projectContent.AddNamespaceContents(result, newName ?? name, projectContent.Language, true); } else { foreach (object o in projectContent.GetNamespaceContents(name)) { if (!(o is string)) { result.Add(o); } } } } if (u.HasAliases) { foreach (string alias in u.Aliases.Keys) { result.Add(alias); } } }
public static ArrayList GetNamespaceMembers(IProjectContent pc, string xmlNamespace) { if (pc == null) { throw new ArgumentNullException("pc"); } if (xmlNamespace == null) { return(null); } if (xmlNamespace.StartsWith("clr-namespace:")) { return(pc.GetNamespaceContents(GetNamespaceNameFromClrNamespace(xmlNamespace))); } else { ArrayList list = new ArrayList(); AddNamespaceMembersInAssembly(pc, xmlNamespace, list); foreach (IProjectContent p in pc.ReferencedContents) { AddNamespaceMembersInAssembly(p, xmlNamespace, list); } return(list); } }
public static IEnumerable <IClass> GetNamespaceMembers(IProjectContent pc, string xmlNamespace) { if (pc == null) { throw new ArgumentNullException("pc"); } if (!string.IsNullOrEmpty(xmlNamespace)) { if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase)) { return(pc.GetNamespaceContents(GetNamespaceNameFromClrNamespace(xmlNamespace)).OfType <IClass>()); } else { var list = new List <ICompletionEntry>(); AddNamespaceMembersInAssembly(pc, xmlNamespace, list); foreach (IProjectContent p in pc.ThreadSafeGetReferencedContents()) { AddNamespaceMembersInAssembly(p, xmlNamespace, list); } return(list.OfType <IClass>()); } } return(Enumerable.Empty <IClass>()); }
static void AddContentsFromCallingClass(List <ICompletionEntry> result, IProjectContent projectContent, IClass callingClass) { if (callingClass == null) { return; } // use HashSet so that Contains lookups are possible in O(1). HashSet <ICompletionEntry> existingResults = new HashSet <ICompletionEntry>(result); string[] namespaceParts = callingClass.Namespace.Split('.'); for (int i = 1; i <= namespaceParts.Length; i++) { foreach (ICompletionEntry member in projectContent.GetNamespaceContents(string.Join(".", namespaceParts, 0, i))) { if (!existingResults.Contains(member)) { result.Add(member); } } } IClass currentClass = callingClass; do { foreach (IClass innerClass in currentClass.GetCompoundClass().GetAccessibleTypes(currentClass)) { if (!existingResults.Contains(innerClass)) { result.Add(innerClass); } } currentClass = currentClass.DeclaringType; } while (currentClass != null); }
void GetCodeElements() { foreach (ICompletionEntry entry in projectContent.GetNamespaceContents(namespaceName.QualifiedName)) { AddCodeElement(entry); } }
public static void AddImportedNamespaceContents(ArrayList result, ICompilationUnit cu, IClass callingClass) { IProjectContent projectContent = cu.ProjectContent; projectContent.AddNamespaceContents(result, "", projectContent.Language, true); foreach (IUsing u in cu.Usings) { AddUsing(result, u, projectContent); } AddUsing(result, projectContent.DefaultImports, projectContent); if (callingClass != null) { string[] namespaceParts = callingClass.Namespace.Split('.'); for (int i = 1; i <= namespaceParts.Length; i++) { foreach (object member in projectContent.GetNamespaceContents(string.Join(".", namespaceParts, 0, i))) { if (!result.Contains(member)) { result.Add(member); } } } IClass currentClass = callingClass; do { foreach (IClass innerClass in currentClass.GetAccessibleTypes(currentClass)) { if (!result.Contains(innerClass)) { result.Add(innerClass); } } currentClass = currentClass.DeclaringType; } while (currentClass != null); } }
ResolveResult ResolveMemberReferenceExpression(IReturnType type, FieldReferenceExpression fieldReferenceExpression) { IClass c; IMember member; if (type is TypeVisitor.NamespaceReturnType) { string combinedName; if (type.FullyQualifiedName == "") { combinedName = fieldReferenceExpression.FieldName; } else { combinedName = type.FullyQualifiedName + "." + fieldReferenceExpression.FieldName; } if (projectContent.NamespaceExists(combinedName)) { return(new NamespaceResolveResult(callingClass, callingMember, combinedName)); } c = GetClass(combinedName); if (c != null) { return(new TypeResolveResult(callingClass, callingMember, c)); } if (languageProperties.ImportModules) { // go through the members of the modules foreach (object o in projectContent.GetNamespaceContents(type.FullyQualifiedName)) { member = o as IMember; if (member != null && IsSameName(member.Name, fieldReferenceExpression.FieldName)) { return(CreateMemberResolveResult(member)); } } } return(null); } member = GetMember(type, fieldReferenceExpression.FieldName); if (member != null) { return(CreateMemberResolveResult(member)); } c = type.GetUnderlyingClass(); if (c != null) { foreach (IClass baseClass in c.ClassInheritanceTree) { List <IClass> innerClasses = baseClass.InnerClasses; if (innerClasses != null) { foreach (IClass innerClass in innerClasses) { if (IsSameName(innerClass.Name, fieldReferenceExpression.FieldName)) { return(new TypeResolveResult(callingClass, callingMember, innerClass)); } } } } } return(ResolveMethod(type, fieldReferenceExpression.FieldName)); }
public static void AddUsing(List<ICompletionEntry> result, IUsing u, IProjectContent projectContent) { if (u == null) { return; } bool importNamespaces = projectContent.Language.ImportNamespaces; bool importClasses = projectContent.Language.CanImportClasses; foreach (string name in u.Usings) { if (importClasses) { IClass c = projectContent.GetClass(name, 0); if (c != null) { ArrayList members = new ArrayList(); IReturnType t = c.DefaultReturnType; members.AddRange(t.GetMethods()); members.AddRange(t.GetFields()); members.AddRange(t.GetEvents()); members.AddRange(t.GetProperties()); foreach (IMember m in members) { if (m.IsStatic && m.IsPublic) { result.Add(m); } } continue; } } if (importNamespaces) { string newName = null; if (projectContent.DefaultImports != null) { newName = projectContent.DefaultImports.SearchNamespace(name); } projectContent.AddNamespaceContents(result, newName ?? name, projectContent.Language, true); } else { foreach (ICompletionEntry o in projectContent.GetNamespaceContents(name)) { if (!(o is NamespaceEntry)) result.Add(o); } } } if (u.HasAliases) { foreach (string alias in u.Aliases.Keys) { result.Add(new AliasEntry(alias)); } } }
static void AddContentsFromCallingClass(List<ICompletionEntry> result, IProjectContent projectContent, IClass callingClass) { if (callingClass == null) { return; } // use HashSet so that Contains lookups are possible in O(1). HashSet<ICompletionEntry> existingResults = new HashSet<ICompletionEntry>(result); string[] namespaceParts = callingClass.Namespace.Split('.'); for (int i = 1; i <= namespaceParts.Length; i++) { foreach (ICompletionEntry member in projectContent.GetNamespaceContents(string.Join(".", namespaceParts, 0, i))) { if (!existingResults.Contains(member)) result.Add(member); } } IClass currentClass = callingClass; do { foreach (IClass innerClass in currentClass.GetCompoundClass().GetAccessibleTypes(currentClass)) { if (!existingResults.Contains(innerClass)) result.Add(innerClass); } currentClass = currentClass.DeclaringType; } while (currentClass != null); }
public override ArrayList GetCompletionData(IProjectContent projectContent) { return(projectContent.GetNamespaceContents(name)); }
public static IEnumerable<IClass> GetNamespaceMembers(IProjectContent pc, string xmlNamespace) { if (pc == null) throw new ArgumentNullException("pc"); if (!string.IsNullOrEmpty(xmlNamespace)) { if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase)) return pc.GetNamespaceContents(GetNamespaceNameFromClrNamespace(xmlNamespace)).OfType<IClass>(); else { var list = new List<ICompletionEntry>(); AddNamespaceMembersInAssembly(pc, xmlNamespace, list); foreach (IProjectContent p in pc.ThreadSafeGetReferencedContents()) { AddNamespaceMembersInAssembly(p, xmlNamespace, list); } return list.OfType<IClass>(); } } return Enumerable.Empty<IClass>(); }
public override List <ICompletionEntry> GetCompletionData(IProjectContent projectContent) { return(projectContent.GetNamespaceContents(name)); }
public override void OnMemberReferenceExpression(MemberReferenceExpression node) { ClearResult(); node.Target.Accept(this); if (resolveResult is NamespaceResolveResult) { string namespaceName = (resolveResult as NamespaceResolveResult).Name; string combinedName; if (namespaceName.Length == 0) { combinedName = node.Name; } else { combinedName = namespaceName + "." + node.Name; } if (projectContent.NamespaceExists(combinedName)) { MakeNamespaceResult(combinedName); return; } IClass c = projectContent.GetClass(combinedName, 0); if (c != null) { MakeTypeResult(c); return; } ClearResult(); // go through the members of the modules in that namespace foreach (object o in projectContent.GetNamespaceContents(namespaceName)) { IMember member = o as IMember; if (member != null && IsSameName(member.Name, node.Name)) { if (member is IMethod) { MakeMethodResult(member.DeclaringType.DefaultReturnType, member.Name); } else { MakeResult(member); } break; } } } else { if (resolveResult != null) { if (resolveResult is TypeResolveResult) { IClass rClass = (resolveResult as TypeResolveResult).ResolvedClass; if (rClass != null) { foreach (IClass baseClass in rClass.ClassInheritanceTree) { foreach (IClass innerClass in baseClass.InnerClasses) { if (IsSameName(innerClass.Name, node.Name)) { MakeTypeResult(innerClass); return; } } } } } ResolveMember(resolveResult.ResolvedType, node.Name); } } }
public override ArrayList GetCompletionData(IProjectContent projectContent) { return projectContent.GetNamespaceContents(name); }