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);
}
}
}
}
private void AddPropertiesFromBaseType(List <IProperty> l, IReturnType baseType)
{
if (baseType != null)
{
foreach (IProperty p in baseType.GetProperties())
{
bool ok = true;
if (p.IsOverridable)
{
StringComparer comparer = p.DeclaringType.ProjectContent.Language.NameComparer;
foreach (IProperty oldProperty in _c.Properties)
{
if (comparer.Equals(oldProperty.Name, p.Name))
{
if (p.IsStatic == oldProperty.IsStatic && object.Equals(p.ReturnType, oldProperty.ReturnType))
{
if (DiffUtility.Compare(oldProperty.Parameters, p.Parameters) == 0)
{
ok = false;
break;
}
}
}
}
}
if (ok)
{
l.Add(p);
}
}
}
}
ArrayList CtrlSpaceForAttributeName(string fileContent, XamlExpressionContext context)
{
if (context.ElementPath.Elements.Count == 0)
{
return(null);
}
QualifiedName lastElement = context.ElementPath.Elements[context.ElementPath.Elements.Count - 1];
XamlCompilationUnit cu = parseInfo.BestCompilationUnit as XamlCompilationUnit;
if (cu == null)
{
return(null);
}
IReturnType rt = cu.CreateType(lastElement.Namespace, lastElement.Name);
if (rt == null)
{
return(null);
}
ArrayList list = new ArrayList();
foreach (IProperty p in rt.GetProperties())
{
if (p.IsPublic && p.CanSet)
{
list.Add(p);
}
}
return(list);
}
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 IProperty GetIndexer(IndexerExpression indexerExpression)
{
IReturnType type = (IReturnType)indexerExpression.TargetObject.AcceptVisitor(this, null);
if (type == null)
{
return(null);
}
List <IProperty> indexers = type.GetProperties();
// remove non-indexers:
for (int i = 0; i < indexers.Count; i++)
{
if (!indexers[i].IsIndexer)
{
indexers.RemoveAt(i--);
}
}
IReturnType[] parameters = new IReturnType[indexerExpression.Indexes.Count];
for (int i = 0; i < parameters.Length; i++)
{
Expression expr = indexerExpression.Indexes[i] as Expression;
if (expr != null)
{
parameters[i] = (IReturnType)expr.AcceptVisitor(this, null);
}
}
return(MemberLookupHelper.FindOverload(indexers.ToArray(), parameters));
}
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 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 <IProperty> GetProperties()
{
IReturnType baseType = BaseType;
List <IProperty> tmp = (baseType != null && TryEnter()) ? baseType.GetProperties() : new List <IProperty>();
_busy = false;
return(tmp);
}
public virtual List <IProperty> GetProperties()
{
IReturnType baseType = BaseType;
using (var l = busyManager.Enter(this)) {
return((l.Success && baseType != null) ? baseType.GetProperties() : new List <IProperty>());
}
}
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));
}
IProperty GetIndexer(IReturnType target, List <Expression> indexes)
{
if (target == null)
{
return(null);
}
return(MemberLookupHelper.FindOverload(
target.GetProperties().Where((IProperty p) => p.IsIndexer).ToList(),
indexes.Select <Expression, IReturnType>(ResolveType).ToArray()
));
}
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 IInsightItem[] ProvideInsight(ExpressionResult expressionResult, ResolveResult result)
{
if (result == null)
{
return(null);
}
IReturnType type = result.ResolvedType;
if (type == null)
{
return(null);
}
return((from p in type.GetProperties()
where p.IsIndexer
select new MethodInsightItem(p)
).ToArray());
}
public override void OnSlicingExpression(SlicingExpression node)
{
ClearResult();
Visit(node.Target);
if (node.Indices.Count > 0)
{
Slice slice = node.Indices[0];
if (slice.End != null)
{
// Boo slice, returns a part of the source -> same type as source
return;
}
}
IReturnType rt = (resolveResult != null) ? resolveResult.ResolvedType : null;
if (rt == null)
{
ClearResult();
return;
}
List <IProperty> indexers = rt.GetProperties();
// remove non-indexers:
for (int i = 0; i < indexers.Count; i++)
{
if (!indexers[i].IsIndexer)
{
indexers.RemoveAt(i--);
}
}
IReturnType[] parameters = new IReturnType[node.Indices.Count];
for (int i = 0; i < parameters.Length; i++)
{
Expression expr = node.Indices[i].Begin as Expression;
if (expr != null)
{
ClearResult();
Visit(expr);
parameters[i] = (resolveResult != null) ? resolveResult.ResolvedType : null;
}
}
MakeResult(MemberLookupHelper.FindOverload(indexers.ToArray(), parameters));
}
public override List <IProperty> GetProperties()
{
List <IProperty> l = baseType.GetProperties();
for (int i = 0; i < l.Count; ++i)
{
if (CheckReturnType(l[i].ReturnType) || CheckParameters(l[i].Parameters))
{
l[i] = (IProperty)l[i].CreateSpecializedMember();
if (l[i].DeclaringType == baseType.GetUnderlyingClass())
{
l[i].DeclaringTypeReference = this;
}
l[i].ReturnType = TranslateType(l[i].ReturnType);
for (int j = 0; j < l[i].Parameters.Count; ++j)
{
l[i].Parameters[j].ReturnType = TranslateType(l[i].Parameters[j].ReturnType);
}
}
}
return(l);
}
protected override void SetupDataProvider(string fileName, SyntaxDocument document, ExpressionResult expressionResult, int caretLineNumber, int caretColumn)
{
ResolveResult result = Parser.ProjectParser.GetResolver().Resolve(expressionResult, caretLineNumber, caretColumn, fileName, document.Text);
if (result == null)
{
return;
}
IReturnType type = result.ResolvedType;
if (type == null)
{
return;
}
foreach (IProperty i in type.GetProperties())
{
if (i.IsIndexer)
{
methods.Add(i);
}
}
}
IProperty GetIndexer(IReturnType target, List<Expression> indexes)
{
if (target == null)
return null;
return MemberLookupHelper.FindOverload(
target.GetProperties().Where((IProperty p) => p.IsIndexer).ToList(),
indexes.Select<Expression, IReturnType>(ResolveType).ToArray()
);
}
static void DoNamedArgsCompletion(XamlCompletionItemList list, XamlCompletionContext context, IReturnType type, MarkupExtensionInfo markup)
{
if (markup.NamedArguments.Count > 0 && !context.Editor.GetWordBeforeCaret().StartsWith(",", StringComparison.OrdinalIgnoreCase)) {
int lastStart = markup.NamedArguments.Max(i => i.Value.StartOffset);
var item = markup.NamedArguments.First(p => p.Value.StartOffset == lastStart);
if (context.RawAttributeValue.EndsWith("=", StringComparison.OrdinalIgnoreCase) ||
(item.Value.IsString && item.Value.StringValue.EndsWith(context.Editor.GetWordBeforeCaretExtended(), StringComparison.Ordinal))) {
MemberResolveResult mrr = XamlResolver.ResolveMember(item.Key, context) as MemberResolveResult;
if (mrr != null && mrr.ResolvedMember != null && mrr.ResolvedMember.ReturnType != null) {
IReturnType memberType = mrr.ResolvedMember.ReturnType;
list.Items.AddRange(MemberCompletion(context, memberType, string.Empty));
}
return;
}
}
list.Items.AddRange(type.GetProperties().Where(p => p.CanSet && p.IsPublic).Select(p => new XamlCodeCompletionItem(p.Name + "=", p)));
}
protected virtual void SetupDataProvider(string fileName, SyntaxDocument document, ExpressionResult expressionResult, int caretLineNumber, int caretColumn)
{
bool constructorInsight = false;
if (expressionResult.Context.IsAttributeContext)
{
constructorInsight = true;
}
else if (expressionResult.Context.IsObjectCreation)
{
constructorInsight = true;
expressionResult.Context = ExpressionContext.Type;
}
ResolveResult results = Parser.ProjectParser.GetResolver().Resolve(expressionResult, caretLineNumber, caretColumn, fileName, document.Text);
LanguageProperties language = Parser.ProjectParser.CurrentProjectContent.Language;
IReturnType type = results.ResolvedType;
if (type != null)
{
foreach (IProperty i in type.GetProperties())
{
if (i.IsIndexer)
{
methods.Add(i);
}
}
}
TypeResolveResult trr = results as TypeResolveResult;
if (trr == null && language.AllowObjectConstructionOutsideContext)
{
if (results is MixedResolveResult)
{
trr = (results as MixedResolveResult).TypeResult;
}
}
if (trr != null && !constructorInsight)
{
if (language.AllowObjectConstructionOutsideContext)
{
constructorInsight = true;
}
}
if (constructorInsight)
{
if (trr == null)
{
return;
}
foreach (IMethod method in trr.ResolvedType.GetMethods())
{
if (method.IsConstructor && !method.IsStatic)
{
methods.Add(method);
}
}
if (methods.Count == 0 && trr.ResolvedClass != null && !trr.ResolvedClass.IsAbstract && !trr.ResolvedClass.IsStatic)
{
// add default constructor
methods.Add(Constructor.CreateDefault(trr.ResolvedClass));
}
}
else
{
MethodResolveResult result = results as MethodResolveResult;
if (result == null)
{
return;
}
bool classIsInInheritanceTree = false;
if (result.CallingClass != null)
{
classIsInInheritanceTree = result.CallingClass.IsTypeInInheritanceTree(result.ContainingType.GetUnderlyingClass());
}
foreach (IMethod method in result.ContainingType.GetMethods())
{
if (language.NameComparer.Equals(method.Name, result.Name))
{
if (method.IsAccessible(result.CallingClass, classIsInInheritanceTree))
{
methods.Add(method);
}
}
}
if (methods.Count == 0 && result.CallingClass != null && language.SupportsExtensionMethods)
{
ArrayList list = new ArrayList();
ResolveResult.AddExtensions(language, list, result.CallingClass, result.ContainingType);
foreach (IMethodOrProperty mp in list)
{
if (language.NameComparer.Equals(mp.Name, result.Name) && mp is IMethod)
{
IMethod m = (IMethod)mp.Clone();
m.Parameters.RemoveAt(0);
methods.Add(m);
}
}
}
}
}
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);
}
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;
}
}
}
void AddPropertiesFromBaseType(List<IProperty> l, IReturnType baseType)
{
if (baseType != null) {
foreach (IProperty p in baseType.GetProperties()) {
/*bool ok = true;
if (p.IsOverridable) {
StringComparer comparer = p.DeclaringType.ProjectContent.Language.NameComparer;
foreach (IProperty oldProperty in c.Properties) {
if (comparer.Equals(oldProperty.Name, p.Name)) {
if (p.IsStatic == oldProperty.IsStatic && object.Equals(p.ReturnType, oldProperty.ReturnType)) {
if (DiffUtility.Compare(oldProperty.Parameters, p.Parameters) == 0) {
ok = false;
break;
}
}
}
}
}
if (ok)
l.Add(p);*/
l.Add(p);
}
}
}
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);
}
/// <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);
}
}
}
}
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;
}
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));
}
}
}
}
