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