public static void AddContentsFromCalling(ArrayList result, IClass callingClass, IMember callingMember)
{
IMethodOrProperty methodOrProperty = callingMember as IMethodOrProperty;
if (methodOrProperty != null)
{
foreach (IParameter p in methodOrProperty.Parameters)
{
result.Add(new DefaultField.ParameterField(p.ReturnType, p.Name, methodOrProperty.Region, callingClass));
}
if (callingMember is IMethod)
{
AddTypeParametersForCtrlSpace(result, ((IMethod)callingMember).TypeParameters);
}
}
bool inStatic = false;
if (callingMember != null)
{
inStatic = callingMember.IsStatic;
}
if (callingClass != null)
{
AddTypeParametersForCtrlSpace(result, callingClass.TypeParameters);
ArrayList members = new ArrayList();
IReturnType t = callingClass.DefaultReturnType;
members.AddRange(t.GetMethods());
members.AddRange(t.GetFields());
members.AddRange(t.GetEvents());
members.AddRange(t.GetProperties());
foreach (IMember m in members)
{
if ((!inStatic || m.IsStatic) && m.IsAccessible(callingClass, true))
{
result.Add(m);
}
}
members.Clear();
IClass c = callingClass.DeclaringType;
while (c != null)
{
t = c.DefaultReturnType;
members.AddRange(t.GetMethods());
members.AddRange(t.GetFields());
members.AddRange(t.GetEvents());
members.AddRange(t.GetProperties());
c = c.DeclaringType;
}
foreach (IMember m in members)
{
if (m.IsStatic)
{
result.Add(m);
}
}
}
}
public IMember GetMember(IReturnType type, string memberName)
{
if (type == null)
{
return(null);
}
bool isClassInInheritanceTree = false;
if (callingClass != null)
{
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(type.GetUnderlyingClass());
}
foreach (IProperty p in type.GetProperties())
{
if (IsSameName(p.Name, memberName))
{
return(p);
}
}
foreach (IField f in type.GetFields())
{
if (IsSameName(f.Name, memberName))
{
return(f);
}
}
foreach (IEvent e in type.GetEvents())
{
if (IsSameName(e.Name, memberName))
{
return(e);
}
}
return(null);
}
public override List <IField> GetFields()
{
if (_getMembersBusy)
{
return(new List <IField>());
}
_getMembersBusy = true;
List <IField> l = new List <IField>();
l.AddRange(_c.Fields);
if (_c.ClassType == ClassType.Interface)
{
foreach (IReturnType baseType in _c.BaseTypes)
{
l.AddRange(baseType.GetFields());
}
}
else
{
IReturnType baseType = _c.BaseType;
if (baseType != null)
{
l.AddRange(baseType.GetFields());
}
}
_getMembersBusy = false;
return(l);
}
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 override List <IField> GetFields()
{
List <IField> l = new List <IField>();
using (var busyLock = busyManager.Enter(this)) {
if (busyLock.Success)
{
l.AddRange(c.Fields);
if (c.ClassType == ClassType.Interface)
{
foreach (IReturnType baseType in c.BaseTypes)
{
l.AddRange(baseType.GetFields());
}
}
else
{
IReturnType baseType = c.BaseType;
if (baseType != null)
{
l.AddRange(baseType.GetFields());
}
}
}
}
return(l);
}
public virtual List <IField> GetFields()
{
IReturnType baseType = BaseType;
using (var l = busyManager.Enter(this)) {
return((l.Success && baseType != null) ? baseType.GetFields() : new List <IField>());
}
}
public virtual List <IField> GetFields()
{
IReturnType baseType = BaseType;
List <IField> tmp = (baseType != null && TryEnter()) ? baseType.GetFields() : new List <IField>();
_busy = false;
return(tmp);
}
public static IEnumerable <IMember> GetMembers(this IReturnType typeReference)
{
var properties = typeReference.GetProperties().Cast <IMember>();
var methods = typeReference.GetMethods().Cast <IMember>();
var fields = typeReference.GetFields().Cast <IMember>();
var events = typeReference.GetEvents().Cast <IMember>();
return(properties.Concat(methods).Concat(fields).Concat(events));
}
public static List <IMember> GetAllMembers(IReturnType rt)
{
List <IMember> members = new List <IMember>();
if (rt != null)
{
rt.GetMethods().ForEach(members.Add);
rt.GetProperties().ForEach(members.Add);
rt.GetFields().ForEach(members.Add);
rt.GetEvents().ForEach(members.Add);
}
return(members);
}
protected ArrayList GetCompletionData(LanguageProperties language, bool showStatic)
{
if (resolvedType == null)
{
return(null);
}
ArrayList res = new ArrayList();
bool isClassInInheritanceTree = false;
if (callingClass != null)
{
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(resolvedType.GetUnderlyingClass());
}
foreach (IMethod m in resolvedType.GetMethods())
{
if (language.ShowMember(m, showStatic) && m.IsAccessible(callingClass, isClassInInheritanceTree))
{
res.Add(m);
}
}
foreach (IEvent e in resolvedType.GetEvents())
{
if (language.ShowMember(e, showStatic) && e.IsAccessible(callingClass, isClassInInheritanceTree))
{
res.Add(e);
}
}
foreach (IField f in resolvedType.GetFields())
{
if (language.ShowMember(f, showStatic) && f.IsAccessible(callingClass, isClassInInheritanceTree))
{
res.Add(f);
}
}
foreach (IProperty p in resolvedType.GetProperties())
{
if (language.ShowMember(p, showStatic) && p.IsAccessible(callingClass, isClassInInheritanceTree))
{
res.Add(p);
}
}
if (!showStatic && callingClass != null)
{
AddExtensions(language, res, callingClass, resolvedType);
}
return(res);
}
public override List <IField> GetFields()
{
List <IField> l = baseType.GetFields();
for (int i = 0; i < l.Count; ++i)
{
if (CheckReturnType(l[i].ReturnType))
{
l[i] = (IField)l[i].CreateSpecializedMember();
if (l[i].DeclaringType == baseType.GetUnderlyingClass())
{
l[i].DeclaringTypeReference = this;
}
l[i].ReturnType = TranslateType(l[i].ReturnType);
}
}
return(l);
}
bool ResolveMember(IReturnType type, string memberName)
{
ClearResult();
if (type == null)
return false;
bool isClassInInheritanceTree = false;
if (callingClass != null)
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(type.GetUnderlyingClass());
foreach (IProperty p in type.GetProperties()) {
if (IsSameName(p.Name, memberName)) {
MakeResult(p);
return true;
}
}
foreach (IField f in type.GetFields()) {
if (IsSameName(f.Name, memberName)) {
MakeResult(f);
return true;
}
}
foreach (IEvent e in type.GetEvents()) {
if (IsSameName(e.Name, memberName)) {
MakeResult(e);
return true;
}
}
foreach (IMethod m in type.GetMethods()) {
if (IsSameName(m.Name, memberName)) {
MakeMethodResult(type, memberName);
return true;
}
}
if (callingClass != null) {
List<IMethodOrProperty> list = new List<IMethodOrProperty>();
ResolveResult.AddExtensions(callingClass.ProjectContent.Language, list.Add, callingClass, type);
foreach (IMethodOrProperty mp in list) {
if (IsSameName(mp.Name, memberName)) {
if (mp is IMethod)
MakeMethodResult(type, memberName);
else
MakeResult(mp);
return true;
}
}
}
return false;
}
bool ResolveMember(IReturnType type, string memberName)
{
ClearResult();
if (type == null)
{
return(false);
}
bool isClassInInheritanceTree = false;
if (callingClass != null)
{
isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(type.GetUnderlyingClass());
}
foreach (IProperty p in type.GetProperties())
{
if (IsSameName(p.Name, memberName))
{
MakeResult(p);
return(true);
}
}
foreach (IField f in type.GetFields())
{
if (IsSameName(f.Name, memberName))
{
MakeResult(f);
return(true);
}
}
foreach (IEvent e in type.GetEvents())
{
if (IsSameName(e.Name, memberName))
{
MakeResult(e);
return(true);
}
}
foreach (IMethod m in type.GetMethods())
{
if (IsSameName(m.Name, memberName))
{
MakeMethodResult(type, memberName);
return(true);
}
}
if (callingClass != null)
{
ArrayList list = new ArrayList();
ResolveResult.AddExtensions(callingClass.ProjectContent.Language, list, callingClass, type);
foreach (IMethodOrProperty mp in list)
{
if (IsSameName(mp.Name, memberName))
{
if (mp is IMethod)
{
MakeMethodResult(type, memberName);
}
else
{
MakeResult(mp);
}
return(true);
}
}
}
return(false);
}
