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); }