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 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 <IEvent> GetEvents()
{
if (_getMembersBusy)
{
return(new List <IEvent>());
}
_getMembersBusy = true;
List <IEvent> l = new List <IEvent>();
l.AddRange(_c.Events);
if (_c.ClassType == ClassType.Interface)
{
foreach (IReturnType baseType in _c.BaseTypes)
{
l.AddRange(baseType.GetEvents());
}
}
else
{
IReturnType baseType = _c.BaseType;
if (baseType != null)
{
l.AddRange(baseType.GetEvents());
}
}
_getMembersBusy = false;
return(l);
}
public override List <IEvent> GetEvents()
{
List <IEvent> l = new List <IEvent>();
using (var busyLock = busyManager.Enter(this)) {
if (busyLock.Success)
{
l.AddRange(c.Events);
if (c.ClassType == ClassType.Interface)
{
foreach (IReturnType baseType in c.BaseTypes)
{
l.AddRange(baseType.GetEvents());
}
}
else
{
IReturnType baseType = c.BaseType;
if (baseType != null)
{
l.AddRange(baseType.GetEvents());
}
}
}
}
return(l);
}
MemberResolveResult ResolveProperty(string xmlNamespace, string className, string propertyName, bool allowAttached)
{
IProjectContent pc = parseInfo.BestCompilationUnit.ProjectContent;
IReturnType resolvedType = XamlCompilationUnit.FindType(pc, xmlNamespace, className);
if (resolvedType != null && resolvedType.GetUnderlyingClass() != null)
{
IMember member = resolvedType.GetProperties().Find(delegate(IProperty p) { return(p.Name == propertyName); });
if (member == null)
{
member = resolvedType.GetEvents().Find(delegate(IEvent p) { return(p.Name == propertyName); });
}
if (member == null && allowAttached)
{
member = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return(p.IsStatic && p.Parameters.Count == 1 && p.Name == "Get" + propertyName);
});
}
if (member != null)
{
return(new MemberResolveResult(callingClass, null, member));
}
}
return(null);
}
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 virtual List <IEvent> GetEvents()
{
IReturnType baseType = BaseType;
using (var l = busyManager.Enter(this)) {
return((l.Success && baseType != null) ? baseType.GetEvents() : new List <IEvent>());
}
}
public virtual List <IEvent> GetEvents()
{
IReturnType baseType = BaseType;
List <IEvent> tmp = (baseType != null && TryEnter()) ? baseType.GetEvents() : new List <IEvent>();
_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 <IEvent> GetEvents()
{
List <IEvent> l = baseType.GetEvents();
for (int i = 0; i < l.Count; ++i)
{
if (CheckReturnType(l[i].ReturnType))
{
l[i] = (IEvent)l[i].CreateSpecializedMember();
if (l[i].DeclaringType == baseType.GetUnderlyingClass())
{
l[i].DeclaringTypeReference = this;
}
l[i].ReturnType = TranslateType(l[i].ReturnType);
}
}
return(l);
}
static void AddAttributes(IReturnType rt, IList<ICompletionItem> list, bool includeEvents)
{
if (rt == null)
return;
foreach (IProperty p in rt.GetProperties()) {
if (p.IsPublic && (p.IsPubliclySetable() || p.ReturnType.IsCollectionReturnType()))
list.Add(new XamlCodeCompletionItem(p));
}
if (includeEvents) {
foreach (IEvent e in rt.GetEvents()) {
if (e.IsPublic) {
list.Add(new XamlCodeCompletionItem(e));
}
}
}
}
MemberResolveResult ResolvePropertyName(IReturnType resolvedType, string propertyName, bool allowAttached)
{
IMember member = resolvedType.GetProperties().Find(delegate(IProperty p) { return p.Name == propertyName; });
if (member == null) {
member = resolvedType.GetEvents().Find(delegate(IEvent p) { return p.Name == propertyName; });
}
if (member == null && allowAttached) {
IMethod method = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return p.IsStatic && p.Parameters.Count == 1 && p.Name == "Get" + propertyName;
});
member = method;
if (member != null) {
member = new DefaultProperty(resolvedType.GetUnderlyingClass(), propertyName) { ReturnType = method.ReturnType };
} else {
IMethod m = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return p.IsPublic && p.IsStatic && p.Parameters.Count == 2 && (p.Name == "Add" + propertyName + "Handler" || p.Name == "Remove" + propertyName + "Handler");
});
member = m;
if (member != null)
member = new DefaultEvent(resolvedType.GetUnderlyingClass(), propertyName) { ReturnType = m.Parameters[1].ReturnType };
}
}
if (member != null)
return new MemberResolveResult(callingClass, null, member);
return null;
}
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);
}
/// <summary>
/// Adds the methods implementing the <paramref name="interf"/> to the list
/// <paramref name="nodes"/>.
/// </summary>
public virtual void ImplementInterface(IList <AbstractNode> nodes, IReturnType interf, bool explicitImpl, IClass targetClass)
{
ClassFinder context = new ClassFinder(targetClass, targetClass.Region.BeginLine + 1, 0);
Modifiers implicitImplModifier = ConvertModifier(ModifierEnum.Public, context);
Modifiers explicitImplModifier = ConvertModifier(context.Language.ExplicitInterfaceImplementationIsPrivateScope ? ModifierEnum.None : ModifierEnum.Public, context);
List <IEvent> targetClassEvents = targetClass.DefaultReturnType.GetEvents();
bool requireAlternativeImplementation;
foreach (IEvent e in interf.GetEvents())
{
if (!InterfaceMemberAlreadyImplemented(targetClassEvents, e, out requireAlternativeImplementation))
{
EventDeclaration ed = ConvertMember(e, context);
ed.Attributes.Clear();
if (explicitImpl || requireAlternativeImplementation)
{
ed.InterfaceImplementations.Add(CreateInterfaceImplementation(e, context));
if (context.Language.RequiresAddRemoveRegionInExplicitInterfaceImplementation)
{
ed.AddRegion = new EventAddRegion(null);
ed.AddRegion.Block = CreateNotImplementedBlock();
ed.RemoveRegion = new EventRemoveRegion(null);
ed.RemoveRegion.Block = CreateNotImplementedBlock();
}
targetClassEvents.Add(CloneAndAddExplicitImpl(e, targetClass));
ed.Modifier = explicitImplModifier;
}
else
{
targetClassEvents.Add(e);
ed.Modifier = implicitImplModifier;
}
nodes.Add(ed);
}
}
List <IProperty> targetClassProperties = targetClass.DefaultReturnType.GetProperties();
foreach (IProperty p in interf.GetProperties())
{
if (!InterfaceMemberAlreadyImplemented(targetClassProperties, p, out requireAlternativeImplementation))
{
AttributedNode pd = ConvertMember(p, context);
pd.Attributes.Clear();
if (explicitImpl || requireAlternativeImplementation)
{
InterfaceImplementation impl = CreateInterfaceImplementation(p, context);
if (pd is IndexerDeclaration)
{
((IndexerDeclaration)pd).InterfaceImplementations.Add(impl);
}
else
{
((PropertyDeclaration)pd).InterfaceImplementations.Add(impl);
}
targetClassProperties.Add(CloneAndAddExplicitImpl(p, targetClass));
pd.Modifier = explicitImplModifier;
}
else
{
targetClassProperties.Add(p);
pd.Modifier = implicitImplModifier;
}
nodes.Add(pd);
}
}
List <IMethod> targetClassMethods = targetClass.DefaultReturnType.GetMethods();
foreach (IMethod m in interf.GetMethods())
{
if (!InterfaceMemberAlreadyImplemented(targetClassMethods, m, out requireAlternativeImplementation))
{
MethodDeclaration md = ConvertMember(m, context) as MethodDeclaration;
md.Attributes.Clear();
if (md != null)
{
if (explicitImpl || requireAlternativeImplementation)
{
md.InterfaceImplementations.Add(CreateInterfaceImplementation(m, context));
targetClassMethods.Add(CloneAndAddExplicitImpl(m, targetClass));
md.Modifier = explicitImplModifier;
}
else
{
targetClassMethods.Add(m);
md.Modifier = implicitImplModifier;
}
nodes.Add(md);
}
}
}
}
static void DoSetterAndEventSetterCompletion(XamlCompletionContext context, XamlCompletionItemList completionList)
{
bool isExplicit;
string element = context.ParentElement.Name.EndsWith("Trigger") ? "Trigger" : context.ParentElement.Name;
AttributeValue value = MarkupExtensionParser.ParseValue(CompletionDataHelper.LookForTargetTypeValue(context, out isExplicit, element) ?? string.Empty);
IReturnType typeName = null;
string typeNameString = null;
if (!value.IsString)
{
typeNameString = CompletionDataHelper.GetTypeNameFromTypeExtension(value.ExtensionValue, context);
typeName = CompletionDataHelper.ResolveType(typeNameString, context);
}
else
{
typeNameString = value.StringValue;
typeName = CompletionDataHelper.ResolveType(value.StringValue, context);
}
if (typeName != null)
{
switch (context.Attribute.Name)
{
case "Value":
AttributeValue propType = MarkupExtensionParser.ParseValue(context.ActiveElement.GetAttributeValue("Property") ?? "");
if (!propType.IsString)
{
break;
}
context.Description = XamlContextDescription.AtTag;
string name = propType.StringValue;
if (!name.Contains("."))
{
name = typeNameString + "." + name;
}
var member = XamlResolver.Resolve(name, context) as MemberResolveResult;
if (member == null || member.ResolvedMember == null)
{
break;
}
completionList.Items.AddRange(
CompletionDataHelper.MemberCompletion(context, member.ResolvedMember.ReturnType, string.Empty)
);
break;
case "Property":
completionList.Items.AddRange(
typeName.GetProperties()
.Where(p => p.IsPublic && p.CanSet)
.Select(prop => new XamlCodeCompletionItem(prop))
);
break;
case "Event":
completionList.Items.AddRange(
typeName.GetEvents()
.Where(e => e.IsPublic)
.Select(evt => new XamlCodeCompletionItem(evt))
);
break;
case "Handler":
var loc3 = context.Editor.Document.OffsetToPosition(XmlParser.GetActiveElementStartIndex(context.Editor.Document.Text, context.Editor.Caret.Offset));
AttributeValue evtType = MarkupExtensionParser.ParseValue(context.ActiveElement.GetAttributeValue("Event") ?? "");
if (!evtType.IsString)
{
break;
}
string evtName = evtType.StringValue;
if (!evtName.Contains("."))
{
evtName = typeNameString + "." + evtName;
}
var evtMember = XamlResolver.Resolve(evtName, context) as MemberResolveResult;
if (evtMember == null || evtMember.ResolvedMember == null || !(evtMember.ResolvedMember is IEvent) || evtMember.ResolvedMember.ReturnType == null)
{
break;
}
IClass c = (evtMember.ResolvedMember as IEvent).ReturnType.GetUnderlyingClass();
if (c == null)
{
break;
}
IMethod invoker = c.Methods.FirstOrDefault(m => m.Name == "Invoke");
if (invoker == null)
{
break;
}
completionList.Items.AddRange(
CompletionDataHelper.AddMatchingEventHandlers(context, invoker).Add(new NewEventCompletionItem(evtMember.ResolvedMember as IEvent, typeName.Name))
);
break;
}
}
}
MemberResolveResult ResolvePropertyName(IReturnType resolvedType, string propertyName, bool allowAttached)
{
IMember member = resolvedType.GetProperties().Find(delegate(IProperty p) { return(p.Name == propertyName); });
if (member == null)
{
member = resolvedType.GetEvents().Find(delegate(IEvent p) { return(p.Name == propertyName); });
}
if (member == null && allowAttached)
{
IMethod method = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return(p.IsStatic && p.Parameters.Count == 1 && p.Name == "Get" + propertyName);
});
member = method;
if (member != null)
{
member = new DefaultProperty(resolvedType.GetUnderlyingClass(), propertyName)
{
ReturnType = method.ReturnType
};
}
else
{
IMethod m = resolvedType.GetMethods().Find(
delegate(IMethod p) {
return(p.IsPublic && p.IsStatic && p.Parameters.Count == 2 && (p.Name == "Add" + propertyName + "Handler" || p.Name == "Remove" + propertyName + "Handler"));
});
member = m;
if (member != null)
{
member = new DefaultEvent(resolvedType.GetUnderlyingClass(), propertyName)
{
ReturnType = m.Parameters[1].ReturnType
}
}
;
}
}
if (member != null)
{
return(new MemberResolveResult(callingClass, null, member));
}
return(null);
}
MemberResolveResult ResolveAttribute(string attributeName)
{
if (context.ActiveElement == null)
{
return(null);
}
string attributeXmlNamespace;
if (attributeName.Contains(":"))
{
string prefix = attributeName.Substring(0, attributeName.IndexOf(':'));
if (!context.XmlnsDefinitions.TryGetValue(prefix, out attributeXmlNamespace))
{
attributeXmlNamespace = null;
}
attributeName = attributeName.Substring(attributeName.IndexOf(':') + 1);
}
else
{
if (!context.XmlnsDefinitions.TryGetValue("", out attributeXmlNamespace))
{
attributeXmlNamespace = null;
}
}
if (attributeName.Contains("."))
{
string className = attributeName.Substring(0, attributeName.IndexOf('.'));
attributeName = attributeName.Substring(attributeName.IndexOf('.') + 1);
return(ResolveProperty(attributeXmlNamespace, className, attributeName, true));
}
else
{
var lastElement = context.ActiveElement;
return(ResolveProperty(lastElement.Namespace, lastElement.LocalName, attributeName, false));
}
}
ResolveResult ResolveAttributeValue(IMember propertyOrEvent, string expression)
{
if (propertyOrEvent == null)
{
return(null);
}
if (propertyOrEvent is IEvent && callingClass != null)
{
return(new MethodGroupResolveResult(callingClass, null, callingClass.DefaultReturnType, expression));
}
else if (propertyOrEvent is IProperty && callingClass != null)
{
if (propertyOrEvent.Name == "Name")
{
foreach (IField f in callingClass.Fields)
{
if (f.Name == expression)
{
return(new MemberResolveResult(callingClass, null, f));
}
}
}
return(ResolveElementName(expression));
}
IReturnType type = propertyOrEvent.ReturnType;
if (type == null)
{
return(null);
}
IClass c = type.GetUnderlyingClass();
if (c == null)
{
return(null);
}
if (c.ClassType == ClassType.Enum)
{
foreach (IField f in c.Fields)
{
if (f.Name == expression)
{
return(new MemberResolveResult(callingClass, null, f));
}
}
}
return(null);
}
