public void GetNamespaceContents()
{
var types = new List <string> ();
foreach (IMember mem in mainProject.GetNamespaceContents("SharedNamespace1", true, true))
{
types.Add(mem.FullName);
}
Assert.IsTrue(types.Contains("SharedNamespace1.A"));
Assert.IsTrue(types.Contains("SharedNamespace1.B"));
Assert.IsTrue(types.Contains("SharedNamespace1.E"));
Assert.IsTrue(types.Contains("SharedNamespace1.F"));
Assert.AreEqual(4, types.Count);
types = new List <string> ();
foreach (IMember mem in mainProject.GetNamespaceContents("SharedNamespace1", false, true))
{
types.Add(mem.FullName);
}
Assert.IsTrue(types.Contains("SharedNamespace1.A"));
Assert.IsTrue(types.Contains("SharedNamespace1.B"));
Assert.AreEqual(2, types.Count);
types = new List <string> ();
foreach (IMember mem in mainProject.GetNamespaceContents("sharednamespace1", true, false))
{
types.Add(mem.FullName);
}
Assert.IsTrue(types.Contains("SharedNamespace1.A"));
Assert.IsTrue(types.Contains("SharedNamespace1.B"));
Assert.IsTrue(types.Contains("SharedNamespace1.E"));
Assert.IsTrue(types.Contains("SharedNamespace1.F"));
Assert.AreEqual(4, types.Count);
types = new List <string> ();
foreach (IMember mem in mainProject.GetNamespaceContents("SharedNamespace2", true, true))
{
types.Add(mem.FullName);
}
Assert.IsTrue(types.Contains("SharedNamespace2.C"));
Assert.IsTrue(types.Contains("SharedNamespace2.D"));
Assert.IsTrue(types.Contains("SharedNamespace2.G"));
Assert.IsTrue(types.Contains("SharedNamespace2.H"));
Assert.AreEqual(4, types.Count);
types = new List <string> ();
foreach (IMember mem in mainProject.GetNamespaceContents("SharedNamespace2", false, true))
{
types.Add(mem.FullName);
}
Assert.AreEqual(0, types.Count);
}
public static void FillNamespaces(ITreeBuilder builder, Project project, string ns)
{
ProjectDom dom = ProjectDomService.GetProjectDom(project);
List <IMember> members = dom.GetNamespaceContents(ns, false, false);
//IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (project);
if (members.Count > 0)
{
if (builder.Options ["ShowProjects"])
{
builder.AddChild(new ProjectNamespaceData(project, ns));
}
else
{
if (!builder.HasChild(ns, typeof(NamespaceData)))
{
builder.AddChild(new ProjectNamespaceData(null, ns));
}
}
}
foreach (IMember ob in members)
{
if (ob is Namespace)
{
FillNamespaces(builder, project, ns + "." + ((Namespace)ob).Name);
}
}
}
public static void BuildChildNodes(ITreeBuilder builder, Project project)
{
if (project is DotNetProject)
{
builder.AddChild(((DotNetProject)project).References);
}
bool publicOnly = builder.Options ["PublicApiOnly"];
ProjectDom dom = ProjectDomService.GetProjectDom(project);
//IParserContext ctx = IdeApp.Workspace.ParserDatabase.GetProjectParserContext (project);
foreach (IMember ob in dom.GetNamespaceContents("", false, false))
{
if (ob is Namespace)
{
if (builder.Options ["NestedNamespaces"])
{
builder.AddChild(new ProjectNamespaceData(project, ((Namespace)ob).Name));
}
else
{
FillNamespaces(builder, project, ((Namespace)ob).Name);
}
}
else if (!publicOnly || ((IType)ob).IsPublic)
{
builder.AddChild(new ClassData(project, ob as IType));
}
}
}
public override IEnumerable <object> CreateResolveResult(ProjectDom dom, IMember callingMember)
{
List <object> result = new List <object> ();
foreach (object o in dom.GetNamespaceContents(ns, true, true))
{
result.Add(o);
}
return(result);
}
/// <summary>
/// Returns a list of types that contains extension methods
/// </summary>
public static List <IType> GetAccessibleExtensionTypes(ProjectDom dom, ICompilationUnit unit)
{
List <IType> result = new List <IType> ();
if (unit != null)
{
List <string> namespaceList = new List <string> ();
namespaceList.Add("");
if (unit != null && unit.Usings != null)
{
foreach (IUsing u in unit.Usings)
{
if (u.Namespaces == null)
{
continue;
}
foreach (string ns in u.Namespaces)
{
namespaceList.Add(ns);
}
}
}
foreach (object o in dom.GetNamespaceContents(namespaceList, true, true))
{
IType type = o as IType;
if (type != null && type.ClassType == ClassType.Class && type.HasExtensionMethods)
{
result.Add(type);
}
}
}
else
{
foreach (IType type in dom.Types)
{
if (type.ClassType == ClassType.Class && type.HasExtensionMethods)
{
result.Add(type);
}
}
foreach (var refDom in dom.References)
{
foreach (IType type in refDom.Types)
{
if (type.ClassType == ClassType.Class && type.HasExtensionMethods)
{
result.Add(type);
}
}
}
}
return(result);
}
public override void AddProjectContent(ITreeBuilder builder)
{
if (project != null)
{
ProjectDom dom = ProjectDomService.GetProjectDom(Project);
AddProjectContent(builder, dom.GetNamespaceContents(FullName, false, false));
}
else
{
foreach (Project p in IdeApp.Workspace.GetAllProjects())
{
ProjectDom dom = ProjectDomService.GetProjectDom(p);
AddProjectContent(builder, dom.GetNamespaceContents(FullName, false, false));
}
}
}
// static ProjectDom GetMLDom (MoonlightProject project)
// {
// return ProjectDomService.GetAssemblyDom (
// MonoDevelop.Core.Runtime.SystemAssemblyService.GetAssemblyNameForVersion (
// "System.Windows", GetProjectTargetFramework (project)));
// }
public static IEnumerable <IType> ListControlClasses(ProjectDom database, string namespac)
{
if (database == null)
{
yield break;
}
DomReturnType swd = new DomReturnType("System.Windows.DependencyObject");
//return classes if they derive from system.web.ui.control
foreach (IMember mem in database.GetNamespaceContents(namespac, true, true))
{
IType cls = mem as IType;
if (cls != null && !cls.IsAbstract && cls.IsPublic && cls.IsBaseType(swd))
{
yield return(cls);
}
}
}
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);
}