diff --git a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs index 118372a089..acf5d7db90 100644 --- a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs +++ b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs @@ -156,7 +156,7 @@ namespace ICSharpCode.Core } builder.Append(' '); } - if (c.ClassType == ClassType.Delegate && c.Methods.Count > 0) { + if (ShowReturnType && c.ClassType == ClassType.Delegate) { foreach(IMethod m in c.Methods) { if (m.Name != "Invoke") continue; @@ -187,7 +187,7 @@ namespace ICSharpCode.Core builder.Append('>'); } - if (c.ClassType == ClassType.Delegate) { + if (ShowReturnType && c.ClassType == ClassType.Delegate) { builder.Append(" ("); if (IncludeHTMLMarkup) builder.Append("
"); @@ -534,19 +534,15 @@ namespace ICSharpCode.Core builder.Append(""); } - /* - for (int i = 0; i < returnType.PointerNestingLevel; ++i) { - builder.Append('*'); - } - - for (int i = 0; i < returnType.ArrayCount; ++i) { - builder.Append('['); - for (int j = 1; j < returnType.ArrayDimensions[i]; ++j) { - builder.Append(','); + if (returnType is SpecificReturnType) { + SpecificReturnType rt = (SpecificReturnType)returnType; + builder.Append('<'); + for (int i = 0; i < rt.TypeParameters.Count; ++i) { + if (i > 0) builder.Append(", "); + builder.Append(Convert(rt.TypeParameters[i])); } - builder.Append(']'); + builder.Append('>'); } - */ return builder.ToString(); } diff --git a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs index d004466e8e..8be8c118d5 100644 --- a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs +++ b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs @@ -51,7 +51,7 @@ namespace VBNetBinding if (decoration.IsStatic) { builder.Append("Shared "); - } + } if (decoration.IsAbstract) { builder.Append("MustOverride "); } else if (decoration.IsFinal) { @@ -206,7 +206,7 @@ namespace VBNetBinding } } - return builder.ToString(); + return builder.ToString(); } public override string ConvertEnd(IClass c) @@ -253,7 +253,7 @@ namespace VBNetBinding builder.Append("Shared "); } } - + if (IncludeHTMLMarkup) { builder.Append(""); builder.Append(""); @@ -272,9 +272,9 @@ namespace VBNetBinding if (field.ReturnType != null && ShowReturnType) { builder.Append(" As "); builder.Append(Convert(field.ReturnType)); - } + } - return builder.ToString(); + return builder.ToString(); } public override string Convert(IProperty property) @@ -407,7 +407,7 @@ namespace VBNetBinding if (m.ReturnType != null && ShowReturnType) { builder.Append(" As "); builder.Append(Convert(m.ReturnType)); - } + } return builder.ToString(); } @@ -482,7 +482,7 @@ namespace VBNetBinding StringBuilder builder = new StringBuilder(); bool linkSet = false; -// TODO: #Assembly dependance: +// TODO: #Assembly dependance: // if (UseLinkArrayList) { // SharpAssemblyReturnType ret = returnType as SharpAssemblyReturnType; @@ -503,20 +503,16 @@ namespace VBNetBinding if (linkSet) { builder.Append(""); } - - /* - for (int i = 0; i < returnType.PointerNestingLevel; ++i) { - builder.Append('*'); - } - for (int i = 0; i < returnType.ArrayCount; ++i) { - builder.Append('('); - for (int j = 1; j < returnType.ArrayDimensions[i]; ++j) { - builder.Append(','); + if (returnType is SpecificReturnType) { + SpecificReturnType rt = (SpecificReturnType)returnType; + builder.Append("(Of"); + for (int i = 0; i < rt.TypeParameters.Count; ++i) { + if (i > 0) builder.Append(", "); + builder.Append(Convert(rt.TypeParameters[i])); } builder.Append(')'); } - */ return builder.ToString(); } @@ -528,7 +524,7 @@ namespace VBNetBinding if (IncludeHTMLMarkup) { builder.Append(""); } - + if (param.IsRef || param.IsOut) { builder.Append("ByRef "); } else if (param.IsParams) { @@ -539,8 +535,8 @@ namespace VBNetBinding if (IncludeHTMLMarkup) { builder.Append(""); } - - + + builder.Append(param.Name); builder.Append(" As "); } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs index c8412fcf9f..a185920d42 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs @@ -19,10 +19,20 @@ namespace ICSharpCode.SharpDevelop.Dom public ArrayReturnType(IReturnType elementType, int dimensions) { + if (dimensions <= 0) + throw new ArgumentOutOfRangeException("dimensions", dimensions, "dimensions must be positive"); + if (elementType == null) + throw new ArgumentNullException("elementType"); this.elementType = elementType; this.dimensions = dimensions; } + public IReturnType ElementType { + get { + return elementType; + } + } + public override string FullyQualifiedName { get { return AppendArrayString(elementType.FullyQualifiedName); diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs index eea133b892..a3f3dcd4f9 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs @@ -42,6 +42,7 @@ namespace ICSharpCode.SharpDevelop.Dom { DefaultMethod p = new DefaultMethod(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType); p.parameters = DefaultParameter.Clone(this.Parameters); + p.documentationTag = DocumentationTag; return p; } @@ -54,23 +55,28 @@ namespace ICSharpCode.SharpDevelop.Dom } } + string documentationTag; + public override string DocumentationTag { get { - string dotnetName = this.DotNetName; - StringBuilder b = new StringBuilder("M:", dotnetName.Length + 2); - b.Append(dotnetName); - List paras = this.Parameters; - if (paras.Count > 0) { - b.Append('('); - for (int i = 0; i < paras.Count; ++i) { - if (i > 0) b.Append(','); - if (paras[i].ReturnType != null) { - b.Append(paras[i].ReturnType.DotNetName); + if (documentationTag == null) { + string dotnetName = this.DotNetName; + StringBuilder b = new StringBuilder("M:", dotnetName.Length + 2); + b.Append(dotnetName); + List paras = this.Parameters; + if (paras.Count > 0) { + b.Append('('); + for (int i = 0; i < paras.Count; ++i) { + if (i > 0) b.Append(','); + if (paras[i].ReturnType != null) { + b.Append(paras[i].ReturnType.DotNetName); + } } + b.Append(')'); } - b.Append(')'); + documentationTag = b.ToString(); } - return b.ToString(); + return documentationTag; } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs index 1097ee5d9f..5b1683e54e 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs @@ -62,9 +62,11 @@ namespace ICSharpCode.SharpDevelop.Dom this.index = index; } - public DefaultTypeParameter(Type type) + public DefaultTypeParameter(IClass targetClass, Type type) { + this.targetClass = targetClass; this.name = type.Name; + this.index = type.GenericParameterPosition; } public override string ToString() diff --git a/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs index 8b74ea1f8e..3113d02b36 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs @@ -20,6 +20,12 @@ namespace ICSharpCode.SharpDevelop.Dom List typeParameters; IReturnType baseType; + public List TypeParameters { + get { + return typeParameters; + } + } + public SpecificReturnType(IReturnType baseType, List typeParameters) { if (baseType == null) @@ -59,9 +65,14 @@ namespace ICSharpCode.SharpDevelop.Dom bool CheckReturnType(IReturnType t) { - GenericReturnType rt = t as GenericReturnType; - if (rt == null) return false; - return rt.TypeParameter.Method == null; + if (t is GenericReturnType) { + GenericReturnType rt = (GenericReturnType)t; + return rt.TypeParameter.Method == null; + } else if (t is ArrayReturnType) { + return CheckReturnType(((ArrayReturnType)t).ElementType); + } else { + return false; + } } bool CheckParameters(List l) @@ -74,11 +85,20 @@ namespace ICSharpCode.SharpDevelop.Dom IReturnType TranslateType(IReturnType input) { - GenericReturnType rt = input as GenericReturnType; - if (rt == null) return input; - if (rt.TypeParameter.Method != null) return input; - if (rt.TypeParameter.Index >= typeParameters.Count) return input; - return typeParameters[rt.TypeParameter.Index]; + if (input is GenericReturnType) { + GenericReturnType rt = (GenericReturnType)input; + if (rt.TypeParameter.Method == null) { + if (rt.TypeParameter.Index < typeParameters.Count) { + return typeParameters[rt.TypeParameter.Index]; + } + } + } else if (input is ArrayReturnType) { + IReturnType e = ((ArrayReturnType)input).ElementType; + IReturnType t = TranslateType(e); + if (e != t) + return new ArrayReturnType(t, input.ArrayDimensions); + } + return input; } public override List GetMethods() @@ -99,18 +119,39 @@ namespace ICSharpCode.SharpDevelop.Dom public override List GetProperties() { List 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].Clone(); + 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; } public override List GetFields() { List l = baseType.GetFields(); + for (int i = 0; i < l.Count; ++i) { + if (CheckReturnType(l[i].ReturnType)) { + l[i] = (IField)l[i].Clone(); + l[i].ReturnType = TranslateType(l[i].ReturnType); + } + } return l; } public override List GetEvents() { List l = baseType.GetEvents(); + for (int i = 0; i < l.Count; ++i) { + if (CheckReturnType(l[i].ReturnType)) { + l[i] = (IEvent)l[i].Clone(); + l[i].ReturnType = TranslateType(l[i].ReturnType); + } + } return l; } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs index a6a548963c..e16e209b88 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs @@ -354,7 +354,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver IReturnType CreateReturnType(AST.TypeReference reference) { - return null; + IClass c = GetCurrentClass(); + if (c == null) return null; + return TypeVisitor.CreateReturnType(reference, c, c.Region.BeginLine + 1, 1); } } } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs index 0a82ea7dbd..6a2569e099 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs @@ -274,7 +274,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver return null; foreach (IMethod method in type.GetMethods()) { if (IsSameName(identifier, method.Name)) - return new MethodResolveResult(callingClass, callingMember, method.DeclaringType, identifier); + return new MethodResolveResult(callingClass, callingMember, type, identifier); } return null; } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs index 363faf3fd8..0b1d78aae7 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs @@ -268,36 +268,15 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(IndexerExpression indexerExpression, object data) { - return null; - /* IReturnType type = (IReturnType)indexerExpression.TargetObject.AcceptVisitor(this, data); if (type == null) { return null; } - if (type.ArrayDimensions == null || type.ArrayDimensions.Length == 0) { - // check if ther is an indexer - if (indexerExpression.TargetObject is ThisReferenceExpression) { - if (resolver.CallingClass == null) { - return null; - } - type = new ReturnType(resolver.CallingClass.FullyQualifiedName); - } - ArrayList indexer = resolver.SearchIndexer(type); - if (indexer.Count == 0) { - return null; - } - // TODO: get the right indexer - return ((IIndexer)indexer[0]).ReturnType; - } - - // TODO: what is a[0] if a is pointer to array or array of pointer ? - if (type.ArrayDimensions[type.ArrayDimensions.Length - 1] != indexerExpression.Indices.Count) { + List indexers = type.GetIndexers(); + if (indexers.Count > 0) + return indexers[0].ReturnType; + else return null; - } - int[] newArray = new int[type.ArrayDimensions.Length - 1]; - Array.Copy(type.ArrayDimensions, 0, newArray, 0, type.ArrayDimensions.Length - 1); - return new ReturnType(type.Name, newArray, type.PointerNestingLevel); - */ } public override object Visit(ClassReferenceExpression classReferenceExpression, object data) @@ -330,12 +309,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(ObjectCreateExpression objectCreateExpression, object data) { - string name = objectCreateExpression.CreateType.Type; - IClass c = resolver.SearchType(name, resolver.CallingClass, resolver.CompilationUnit); - if (c != null) - name = c.FullyQualifiedName; - return c.DefaultReturnType; - //return new ReturnType(name, objectCreateExpression.CreateType.RankSpecifier, objectCreateExpression.CreateType.PointerNestingLevel); + return CreateReturnType(objectCreateExpression.CreateType); } public override object Visit(ArrayCreateExpression arrayCreateExpression, object data) @@ -372,8 +346,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver) { if (reference.IsNull) return null; - IResolveContext context = new SearchClassResolveContext(resolver.CallingClass, resolver.CaretLine, resolver.CaretColumn); - IReturnType t = new LazyReturnType(context, reference.SystemType); + IClass c = resolver.SearchType(reference.SystemType, resolver.CallingClass); + if (c == null) return null; + IReturnType t = c.DefaultReturnType; if (reference.GenericTypes.Count > 0) { List para = new List(reference.GenericTypes.Count); for (int i = 0; i < reference.GenericTypes.Count; ++i) { @@ -381,9 +356,29 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } t = new SpecificReturnType(t, para); } + return WrapArray(t, reference); + } + + public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, int caretLine, int caretColumn) + { + if (reference.IsNull) return null; + IResolveContext context = new SearchClassResolveContext(callingClass, caretLine, caretColumn); + IReturnType t = new LazyReturnType(context, reference.SystemType); + if (reference.GenericTypes.Count > 0) { + List para = new List(reference.GenericTypes.Count); + for (int i = 0; i < reference.GenericTypes.Count; ++i) { + para.Add(CreateReturnType(reference.GenericTypes[i], callingClass, caretLine, caretColumn)); + } + t = new SpecificReturnType(t, para); + } + return WrapArray(t, reference); + } + + static IReturnType WrapArray(IReturnType t, TypeReference reference) + { if (reference.IsArrayType) { for (int i = 0; i < reference.RankSpecifier.Length; ++i) { - t = new ArrayReturnType(t, reference.RankSpecifier[i]); + t = new ArrayReturnType(t, reference.RankSpecifier[i] + 1); } } return t; diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs index 84b8f60bb3..181dc22e00 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs @@ -155,7 +155,7 @@ namespace ICSharpCode.SharpDevelop.Dom } if (type.IsGenericTypeDefinition) { foreach (Type g in type.GetGenericArguments()) { - this.TypeParameters.Add(new DefaultTypeParameter(g)); + this.TypeParameters.Add(new DefaultTypeParameter(this, g)); } } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs index 0649d2e010..a96dd8f367 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs @@ -30,7 +30,18 @@ namespace ICSharpCode.SharpDevelop.Dom return MakeArray(type, Create(member, type.GetElementType())); } else if (type.IsGenericParameter) { IClass c = member.DeclaringType; - return new GenericReturnType(c.TypeParameters[type.GenericParameterPosition]); + if (type.GenericParameterPosition < c.TypeParameters.Count) { + if (c.TypeParameters[type.GenericParameterPosition].Name == type.Name) { + return new GenericReturnType(c.TypeParameters[type.GenericParameterPosition]); + } + } + if (type.DeclaringMethod != null) { + IMethod method = member as IMethod; + if (method != null) { + // Create GenericReturnType for generic method + } + } + return new GenericReturnType(new DefaultTypeParameter(c, type)); } return Create(member.DeclaringType.ProjectContent, type); } diff --git a/src/Main/Base/Project/Src/Dom/ResolveResult.cs b/src/Main/Base/Project/Src/Dom/ResolveResult.cs index 93dd4127b8..b782a8cb42 100644 --- a/src/Main/Base/Project/Src/Dom/ResolveResult.cs +++ b/src/Main/Base/Project/Src/Dom/ResolveResult.cs @@ -340,21 +340,22 @@ namespace ICSharpCode.SharpDevelop.Dom /// /// Example expressions: /// "System.Console.WriteLine" + /// "a.Add" (where a is List<string>) /// "SomeMethod" (when SomeMethod is a method in the current class) /// public class MethodResolveResult : ResolveResult { string name; - IClass containingClass; + IReturnType containingType; - public MethodResolveResult(IClass callingClass, IMember callingMember, IClass containingClass, string name) + public MethodResolveResult(IClass callingClass, IMember callingMember, IReturnType containingType, string name) : base(callingClass, callingMember, null) { - if (containingClass == null) - throw new ArgumentNullException("containingClass"); + if (containingType == null) + throw new ArgumentNullException("containingType"); if (name == null) throw new ArgumentNullException("name"); - this.containingClass = containingClass; + this.containingType = containingType; this.name = name; } @@ -368,11 +369,11 @@ namespace ICSharpCode.SharpDevelop.Dom } /// - /// Gets the class on that contains the method. + /// Gets the class that contains the method. /// - public IClass ContainingClass { + public IReturnType ContainingType { get { - return containingClass; + return containingType; } } } diff --git a/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs b/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs index 0483726c5f..0ad6d16717 100644 --- a/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs +++ b/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs @@ -257,29 +257,18 @@ namespace ICSharpCode.Core // } } + string name = returnType.DotNetName; if (UseFullyQualifiedNames) { - builder.Append(returnType.FullyQualifiedName); + builder.Append(name); } else { - builder.Append(returnType.Name); + int pos = returnType.Namespace.Length; + builder.Append(name, pos, name.Length - pos); } if (linkSet) { builder.Append(""); } - // TODO: Re-write this! - /*for (int i = 0; i < returnType.PointerNestingLevel; ++i) { - builder.Append('*'); - } - - for (int i = 0; i < returnType.ArrayCount; ++i) { - builder.Append('['); - for (int j = 1; j < returnType.ArrayDimensions[i]; ++j) { - builder.Append(','); - } - builder.Append(']'); - }*/ - return builder.ToString(); } diff --git a/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs b/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs index 47abfc6e9c..c9d12981ce 100644 --- a/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs +++ b/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs @@ -71,17 +71,18 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor IReturnType type = result.ResolvedType; if (type == null) return; + /* IProjectContent projectContent = ParserService.CurrentProjectContent; if (projectContent == null) return; IClass c = projectContent.GetClass(type.FullyQualifiedName); if (c == null) return; - bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass); - foreach (IIndexer i in c.Indexer) { - if (i.IsAccessible(result.CallingClass, canViewProtected)) { + bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass);*/ + foreach (IIndexer i in type.GetIndexers()) { + //if (i.IsAccessible(result.CallingClass, canViewProtected)) { methods.Add(i); - } + //} } } diff --git a/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs b/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs index 45abdca7d2..1ccb2423b7 100644 --- a/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs +++ b/src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs @@ -76,29 +76,18 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor TypeResolveResult result = results as TypeResolveResult; if (result == null) return; - IClass c = result.ResolvedClass; - bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass); - foreach (IMethod method in c.Methods) { + foreach (IMethod method in result.ResolvedType.GetMethods()) { if (method.IsConstructor) { - if (method.IsAccessible(result.CallingClass, canViewProtected)) { - methods.Add(method); - } + methods.Add(method); } } } else { MethodResolveResult result = results as MethodResolveResult; if (result == null) return; - IClass c = result.ContainingClass; - bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass); - foreach (IClass curType in c.ClassInheritanceTree) { - foreach (IMethod method in curType.Methods) { - if (method.Name == result.Name) { - if (method.IsAccessible(result.CallingClass, canViewProtected)) { - // TODO: exclude methods that were overridden - methods.Add(method); - } - } + foreach (IMethod method in result.ContainingType.GetMethods()) { + if (method.Name == result.Name) { + methods.Add(method); } } }