diff --git a/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj b/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj index 1c99330c6b..92d30862ca 100644 --- a/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj +++ b/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj @@ -643,6 +643,9 @@ + + + diff --git a/src/Main/Base/Project/Src/Dom/IMember.cs b/src/Main/Base/Project/Src/Dom/IMember.cs index aa11c2d33b..ae6226a29c 100644 --- a/src/Main/Base/Project/Src/Dom/IMember.cs +++ b/src/Main/Base/Project/Src/Dom/IMember.cs @@ -9,7 +9,7 @@ using System.Reflection; namespace ICSharpCode.SharpDevelop.Dom { - public interface IMember : IDecoration + public interface IMember : IDecoration, ICloneable { string FullyQualifiedName { get; diff --git a/src/Main/Base/Project/Src/Dom/IParameter.cs b/src/Main/Base/Project/Src/Dom/IParameter.cs index 97e85203f3..228876df62 100644 --- a/src/Main/Base/Project/Src/Dom/IParameter.cs +++ b/src/Main/Base/Project/Src/Dom/IParameter.cs @@ -19,6 +19,7 @@ namespace ICSharpCode.SharpDevelop.Dom IReturnType ReturnType { get; + set; } List Attributes { diff --git a/src/Main/Base/Project/Src/Dom/IReturnType.cs b/src/Main/Base/Project/Src/Dom/IReturnType.cs index 2958faecee..410c5673fe 100644 --- a/src/Main/Base/Project/Src/Dom/IReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/IReturnType.cs @@ -30,9 +30,9 @@ namespace ICSharpCode.SharpDevelop.Dom /// /// Gets the array ranks of the return type. - /// When the return type is not an array, this property returns null. + /// When the return type is not an array, this property returns 0. /// - int[] ArrayDimensions { + int ArrayDimensions { get; } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/AbstractMember.cs b/src/Main/Base/Project/Src/Dom/Implementations/AbstractMember.cs index 9fe6b40cd1..e4f309d0e0 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/AbstractMember.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/AbstractMember.cs @@ -36,5 +36,12 @@ namespace ICSharpCode.SharpDevelop.Dom public AbstractMember(IClass declaringType, string name) : base(declaringType, name) { } + + public abstract IMember Clone(); + + object ICloneable.Clone() + { + return this.Clone(); + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs index 4563db406e..75e63a41e0 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs @@ -19,6 +19,18 @@ namespace ICSharpCode.SharpDevelop.Dom public abstract List GetEvents(); public abstract List GetIndexers(); + public override bool Equals(object o) + { + AbstractReturnType rt = o as AbstractReturnType; + if (rt == null) return false; + return this.fullyQualifiedName == rt.fullyQualifiedName; + } + + public override int GetHashCode() + { + return fullyQualifiedName.GetHashCode(); + } + string fullyQualifiedName = null; public virtual string FullyQualifiedName { @@ -59,9 +71,9 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public int[] ArrayDimensions { + public int ArrayDimensions { get { - return null; + return 0; } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs new file mode 100644 index 0000000000..c8412fcf9f --- /dev/null +++ b/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs @@ -0,0 +1,85 @@ +// +// +// +// +// +// + +using System; +using System.Collections.Generic; +using System.Text; +using ICSharpCode.Core; + +namespace ICSharpCode.SharpDevelop.Dom +{ + public sealed class ArrayReturnType : ProxyReturnType + { + IReturnType elementType; + int dimensions; + + public ArrayReturnType(IReturnType elementType, int dimensions) + { + this.elementType = elementType; + this.dimensions = dimensions; + } + + public override string FullyQualifiedName { + get { + return AppendArrayString(elementType.FullyQualifiedName); + } + } + + public override string Name { + get { + return AppendArrayString(elementType.Name); + } + } + + public override string DotNetName { + get { + return AppendArrayString(elementType.DotNetName); + } + } + + public override IReturnType BaseType { + get { + return ProjectContentRegistry.GetMscorlibContent().GetClass("System.Array").DefaultReturnType; + } + } + + public override List GetIndexers() + { + IClass arr = ProjectContentRegistry.GetMscorlibContent().GetClass("System.Array"); + IReturnType intRT = ProjectContentRegistry.GetMscorlibContent().GetClass("System.Int32").DefaultReturnType; + List p = new List(); + for (int i = 0; i < dimensions; ++i) { + p.Add(new DefaultParameter("index", intRT, null)); + } + List l = new List(); + l.Add(new DefaultIndexer(elementType, p, ModifierEnum.Public, null, null, arr)); + return l; + } + + public override int ArrayDimensions { + get { + return dimensions; + } + } + + string AppendArrayString(string a) + { + StringBuilder b = new StringBuilder(a, a.Length + 1 + dimensions); + b.Append('['); + for (int i = 1; i < dimensions; ++i) { + b.Append(','); + } + b.Append(']'); + return b.ToString(); + } + + public override string ToString() + { + return String.Format("[ArrayReturnType: {0}, dimensions={1}]", elementType, AppendArrayString("")); + } + } +} diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs index bf76412be8..5d7d5af3bb 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs @@ -7,7 +7,7 @@ using System; using System.Reflection; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom { [Serializable] public class DefaultEvent : AbstractMember, IEvent @@ -36,6 +36,11 @@ namespace ICSharpCode.SharpDevelop.Dom } } + public override IMember Clone() + { + return new DefaultEvent(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType); + } + protected DefaultEvent(IClass declaringType, string name) : base(declaringType, name) { } @@ -51,7 +56,7 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public virtual int CompareTo(IEvent value) + public virtual int CompareTo(IEvent value) { int cmp; @@ -64,11 +69,11 @@ namespace ICSharpCode.SharpDevelop.Dom return cmp; } } - + return Region.CompareTo(value.Region); } - int IComparable.CompareTo(object value) + int IComparable.CompareTo(object value) { return CompareTo((IEvent)value); } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs index 8cc5ccbb08..f7e4814eb1 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs @@ -29,6 +29,11 @@ namespace ICSharpCode.SharpDevelop.Dom this.Modifiers = m; } + public override IMember Clone() + { + return new DefaultField(ReturnType, Name, Modifiers, Region, DeclaringType); + } + public virtual int CompareTo(IField field) { int cmp; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs index 87fbf97c80..2db7f48c27 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs @@ -24,14 +24,17 @@ namespace ICSharpCode.SharpDevelop.Dom } } + public override IMember Clone() + { + return new DefaultIndexer(ReturnType, DefaultParameter.Clone(this.Parameters), Modifiers, Region, BodyRegion, DeclaringType); + } public virtual IRegion BodyRegion { get { return bodyRegion; } } - - + public IRegion GetterRegion { get { return getterRegion; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs index 6b6adf7df7..eea133b892 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs @@ -38,6 +38,13 @@ namespace ICSharpCode.SharpDevelop.Dom List parameters = null; List typeParameters = null; + public override IMember Clone() + { + DefaultMethod p = new DefaultMethod(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType); + p.parameters = DefaultParameter.Clone(this.Parameters); + return p; + } + public override string DotNetName { get { if (typeParameters == null || typeParameters.Count == 0) diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs index 5cf977c2c8..83c5e372f8 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs @@ -29,6 +29,14 @@ namespace ICSharpCode.SharpDevelop.Dom Name = name; } + public DefaultParameter(IParameter p) + { + this.name = p.Name; + this.region = p.Region; + this.modifier = p.Modifier; + this.returnType = p.ReturnType; + } + public DefaultParameter(string name, IReturnType type, IRegion region) : this(name) { returnType = type; @@ -114,6 +122,15 @@ namespace ICSharpCode.SharpDevelop.Dom } } + public static List Clone(List l) + { + List r = new List(l.Count); + for (int i = 0; i < l.Count; ++i) { + r.Add(new DefaultParameter(l[i])); + } + return r; + } + public virtual int CompareTo(IParameter value) { int cmp; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs index 8c047ffce7..d7b0d96302 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs @@ -33,8 +33,14 @@ namespace ICSharpCode.SharpDevelop.Dom { return bodyRegion; } } - - + + public override IMember Clone() + { + DefaultProperty p = new DefaultProperty(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType); + p.parameters = DefaultParameter.Clone(this.Parameters); + return p; + } + public virtual List Parameters { get { if (parameters == null) { diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs index a9ae53fa42..4871b809cc 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs @@ -77,7 +77,7 @@ namespace ICSharpCode.SharpDevelop.Dom return c.Name; } } - + public override string Namespace { get { return c.Namespace; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs index 7101f9e985..1097ee5d9f 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs @@ -66,5 +66,10 @@ namespace ICSharpCode.SharpDevelop.Dom { this.name = type.Name; } + + public override string ToString() + { + return String.Format("[{0}: {1}]", GetType().Name, name); + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs new file mode 100644 index 0000000000..c94e14a2aa --- /dev/null +++ b/src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs @@ -0,0 +1,85 @@ +// +// +// +// +// +// + +using System; +using System.Collections.Generic; +using ICSharpCode.Core; + +namespace ICSharpCode.SharpDevelop.Dom +{ + /// + /// GenericReturnType is a reference to a type parameter. + /// + public sealed class GenericReturnType : ProxyReturnType + { + ITypeParameter typeParameter; + + public ITypeParameter TypeParameter { + get { + return typeParameter; + } + } + + public override bool Equals(object o) + { + GenericReturnType rt = o as GenericReturnType; + if (rt == null) return false; + return typeParameter.Equals(rt.typeParameter); + } + + public override int GetHashCode() + { + return typeParameter.GetHashCode(); + } + + public GenericReturnType(ITypeParameter typeParameter) + { + if (typeParameter == null) + throw new ArgumentNullException("typeParameter"); + this.typeParameter = typeParameter; + } + + public override string FullyQualifiedName { + get { + return typeParameter.Name; + } + } + + public override string Name { + get { + return typeParameter.Name; + } + } + + public override string Namespace { + get { + return ""; + } + } + + public override string DotNetName { + get { + if (typeParameter.Method != null) + return "``" + typeParameter.Index; + else + return "`" + typeParameter.Index; + } + } + + public override IReturnType BaseType { + get { + return null; + // return typeParameter.Constraint; + } + } + + public override string ToString() + { + return String.Format("[GenericReturnType: {0}]", typeParameter); + } + } +} diff --git a/src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs index 52a1415dd4..ad07322844 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs @@ -38,6 +38,19 @@ namespace ICSharpCode.SharpDevelop.Dom this.data = data; } + public override bool Equals(object o) + { + LazyReturnType rt = o as LazyReturnType; + if (rt == null) return false; + if (!context.Equals(rt.context)) return false; + return data.Equals(rt.data); + } + + public override int GetHashCode() + { + return context.GetHashCode() ^ data.GetHashCode(); + } + public override IReturnType BaseType { get { return context.Resolve(data); @@ -66,6 +79,18 @@ namespace ICSharpCode.SharpDevelop.Dom IClass c = content.GetClass((string)data); return (c != null) ? c.DefaultReturnType : null; } + + public override bool Equals(object obj) + { + GetClassResolveContext b = obj as GetClassResolveContext; + if (b == null) return false; + return content == b.content; + } + + public override int GetHashCode() + { + return content.GetHashCode(); + } } public class SearchClassResolveContext : IResolveContext @@ -86,5 +111,20 @@ namespace ICSharpCode.SharpDevelop.Dom IClass c = declaringClass.ProjectContent.SearchType((string)data, declaringClass, caretLine, caretColumn); return (c != null) ? c.DefaultReturnType : null; } + + public override bool Equals(object obj) + { + SearchClassResolveContext b = obj as SearchClassResolveContext; + if (b == null) return false; + if (declaringClass != b.declaringClass) return false; + if (caretLine != b.caretLine) return false; + if (caretColumn != b.caretColumn) return false; + return true; + } + + public override int GetHashCode() + { + return declaringClass.GetHashCode() ^ caretLine ^ caretColumn; + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs index 6eba342e9a..f9e26f908e 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs @@ -49,38 +49,38 @@ namespace ICSharpCode.SharpDevelop.Dom /// Gets the array ranks of the return type. /// When the return type is not an array, this property returns null. /// - public virtual int[] ArrayDimensions { + public virtual int ArrayDimensions { get { IReturnType baseType = BaseType; - return (baseType != null) ? baseType.ArrayDimensions : null; + return (baseType != null) ? baseType.ArrayDimensions : 0; } } - public List GetMethods() + public virtual List GetMethods() { IReturnType baseType = BaseType; return (baseType != null) ? baseType.GetMethods() : new List(); } - public List GetProperties() + public virtual List GetProperties() { IReturnType baseType = BaseType; return (baseType != null) ? baseType.GetProperties() : new List(); } - public List GetFields() + public virtual List GetFields() { IReturnType baseType = BaseType; return (baseType != null) ? baseType.GetFields() : new List(); } - public List GetEvents() + public virtual List GetEvents() { IReturnType baseType = BaseType; return (baseType != null) ? baseType.GetEvents() : new List(); } - public List GetIndexers() + public virtual List GetIndexers() { IReturnType baseType = BaseType; return (baseType != null) ? baseType.GetIndexers() : new List(); diff --git a/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs new file mode 100644 index 0000000000..8b74ea1f8e --- /dev/null +++ b/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs @@ -0,0 +1,137 @@ +// +// +// +// +// +// + +using System; +using System.Collections.Generic; +using ICSharpCode.Core; + +namespace ICSharpCode.SharpDevelop.Dom +{ + /// + /// SpecificReturnType is a reference to class where the type parameters are specified. + /// Example: List<string> + /// + public sealed class SpecificReturnType : ProxyReturnType + { + List typeParameters; + IReturnType baseType; + + public SpecificReturnType(IReturnType baseType, List typeParameters) + { + if (baseType == null) + throw new ArgumentNullException("baseType"); + if (typeParameters == null) + throw new ArgumentNullException("typeParameter"); + this.typeParameters = typeParameters; + this.baseType = baseType; + } + + public override bool Equals(object o) + { + SpecificReturnType rt = o as SpecificReturnType; + if (rt == null) return false; + if (!baseType.Equals(rt.baseType)) return false; + if (typeParameters.Count != rt.typeParameters.Count) return false; + for (int i = 0; i < typeParameters.Count; ++i) { + if (!typeParameters[i].Equals(rt.typeParameters[i])) return false; + } + return true; + } + + public override int GetHashCode() + { + int code = baseType.GetHashCode(); + foreach (IReturnType t in typeParameters) { + code ^= t.GetHashCode(); + } + return code; + } + + public override IReturnType BaseType { + get { + return baseType; + } + } + + bool CheckReturnType(IReturnType t) + { + GenericReturnType rt = t as GenericReturnType; + if (rt == null) return false; + return rt.TypeParameter.Method == null; + } + + bool CheckParameters(List l) + { + foreach (IParameter p in l) { + if (CheckReturnType(p.ReturnType)) return true; + } + return false; + } + + 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]; + } + + public override List GetMethods() + { + List l = baseType.GetMethods(); + for (int i = 0; i < l.Count; ++i) { + if (CheckReturnType(l[i].ReturnType) || CheckParameters(l[i].Parameters)) { + l[i] = (IMethod)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 GetProperties() + { + List l = baseType.GetProperties(); + return l; + } + + public override List GetFields() + { + List l = baseType.GetFields(); + return l; + } + + public override List GetEvents() + { + List l = baseType.GetEvents(); + return l; + } + + public override List GetIndexers() + { + List l = baseType.GetIndexers(); + for (int i = 0; i < l.Count; ++i) { + if (CheckReturnType(l[i].ReturnType) || CheckParameters(l[i].Parameters)) { + l[i] = (IIndexer)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 string ToString() + { + return String.Format("[SpecificReturnType: {0}<{1}>]", baseType, typeParameters); + } + } +} diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs index c1fddc2a2e..0a82ea7dbd 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs @@ -58,6 +58,18 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } } + public int CaretLine { + get { + return caretLine; + } + } + + public int CaretColumn { + get { + return caretColumn; + } + } + public NRefactoryResolver(SupportedLanguages language) { this.language = language; @@ -550,13 +562,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (v == null) { return null; } - IClass c = SearchType(v.TypeRef.SystemType, callingClass, cu); - if (c != null) { - return c.DefaultReturnType; - } else { - //return new ReturnType(v.TypeRef); - return null; - } + return TypeVisitor.CreateReturnType(v.TypeRef, this); } LocalLookupVariable SearchVariable(string name) diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs index 25ec9abadf..363faf3fd8 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs @@ -2,6 +2,7 @@ using System; using System.Collections; +using System.Collections.Generic; using ICSharpCode.NRefactory.Parser; using ICSharpCode.NRefactory.Parser.AST; @@ -23,7 +24,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(PrimitiveExpression primitiveExpression, object data) { if (primitiveExpression.Value != null) { - return ReflectionReturnType(primitiveExpression.Value.GetType()); + return CreateReturnType(primitiveExpression.Value.GetType()); } return null; } @@ -141,7 +142,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (name != null) { string n = resolver.SearchNamespace(name + "." + fieldReferenceExpression.FieldName, null); if (n != null) { - return NamespaceReturnType(n); + return CreateNamespaceReturnType(n); } IClass c = resolver.SearchType(name + "." + fieldReferenceExpression.FieldName, resolver.CallingClass, resolver.CompilationUnit); if (c != null) { @@ -178,11 +179,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } string name = resolver.SearchNamespace(identifierExpression.Identifier, resolver.CompilationUnit); if (name != null && name != "") { - return NamespaceReturnType(name); + return CreateNamespaceReturnType(name); } IClass c = resolver.SearchType(identifierExpression.Identifier, resolver.CallingClass, resolver.CompilationUnit); if (c != null) { - return c.DefaultReturnType;; + return c.DefaultReturnType; } return resolver.DynamicLookup(identifierExpression.Identifier); } @@ -234,12 +235,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(SizeOfExpression sizeOfExpression, object data) { - return ReflectionReturnType(typeof(int)); + return CreateReturnType(typeof(int)); } public override object Visit(TypeOfExpression typeOfExpression, object data) { - return ReflectionReturnType(typeof(Type)); + return CreateReturnType(typeof(Type)); } public override object Visit(CheckedExpression checkedExpression, object data) @@ -365,17 +366,38 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver IReturnType CreateReturnType(TypeReference reference) { - return null; + return CreateReturnType(reference, resolver); } - IReturnType NamespaceReturnType(string namespaceName) + public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver) { - return null; + if (reference.IsNull) return null; + IResolveContext context = new SearchClassResolveContext(resolver.CallingClass, resolver.CaretLine, resolver.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], resolver)); + } + t = new SpecificReturnType(t, para); + } + if (reference.IsArrayType) { + for (int i = 0; i < reference.RankSpecifier.Length; ++i) { + t = new ArrayReturnType(t, reference.RankSpecifier[i]); + } + } + return t; } - IReturnType ReflectionReturnType(Type t) + IReturnType CreateNamespaceReturnType(string namespaceName) { return null; } + + IReturnType CreateReturnType(Type type) + { + return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), + type); + } } } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs index e890980e0e..995b9f5ef3 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs @@ -30,7 +30,7 @@ namespace ICSharpCode.SharpDevelop.Dom get { List parameters = new List(); foreach (ParameterInfo parameterInfo in propertyInfo.GetIndexParameters()) { - parameters.Add(new ReflectionParameter(parameterInfo, DeclaringType.ProjectContent)); + parameters.Add(new ReflectionParameter(parameterInfo, this)); } return parameters; } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs index e957fec5f1..f00409e4e8 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs @@ -40,7 +40,7 @@ namespace ICSharpCode.SharpDevelop.Dom get { List parameters = new List(); foreach (ParameterInfo paramInfo in methodBase.GetParameters()) { - parameters.Add(new ReflectionParameter(paramInfo, DeclaringType.ProjectContent)); + parameters.Add(new ReflectionParameter(paramInfo, this)); } return parameters; } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs index c5726575d5..6671cfaa01 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs @@ -15,20 +15,20 @@ namespace ICSharpCode.SharpDevelop.Dom public class ReflectionParameter : DefaultParameter { ParameterInfo parameterInfo; - IProjectContent content; + IMember member; public override IReturnType ReturnType { get { - return ReflectionReturnType.Create(content, parameterInfo.ParameterType); + return ReflectionReturnType.Create(member, parameterInfo.ParameterType); } set { } } - public ReflectionParameter(ParameterInfo parameterInfo, IProjectContent content) : base(parameterInfo.Name) + public ReflectionParameter(ParameterInfo parameterInfo, IMember member) : base(parameterInfo.Name) { this.parameterInfo = parameterInfo; - this.content = content; + this.member = member; if (parameterInfo.IsOut) { modifier |= ParameterModifier.Out; diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs index 2996027c6d..0649d2e010 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs @@ -15,17 +15,30 @@ namespace ICSharpCode.SharpDevelop.Dom public static IReturnType Create(IProjectContent content, Type type) { string name = type.FullName; - if (name == null) { - // this could be a generic type + if (name == null) return null; + if (type.IsArray) { + return MakeArray(type, Create(content, type.GetElementType())); + } else { + return new LazyReturnType(new GetClassResolveContext(content), name); } - return new LazyReturnType(new GetClassResolveContext(content), name); } public static IReturnType Create(IMember member, Type type) { + if (type.IsArray) { + return MakeArray(type, Create(member, type.GetElementType())); + } else if (type.IsGenericParameter) { + IClass c = member.DeclaringType; + return new GenericReturnType(c.TypeParameters[type.GenericParameterPosition]); + } return Create(member.DeclaringType.ProjectContent, type); } + + static IReturnType MakeArray(Type type, IReturnType baseType) + { + return new ArrayReturnType(baseType, type.GetArrayRank()); + } } /* @@ -74,5 +87,5 @@ namespace ICSharpCode.SharpDevelop.Dom } } } - */ + */ } diff --git a/src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CodeCompletionData.cs b/src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CodeCompletionData.cs index 2411c77dd3..ec35cca1bc 100644 --- a/src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CodeCompletionData.cs +++ b/src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CodeCompletionData.cs @@ -60,36 +60,13 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor public string Description { get { - // get correct delegate description (when description is requested) - // in the classproxies aren't methods saved, therefore delegate methods - // must be get through the real class instead out of the proxy - // - // Mike -// TODO: Still useful ? -// if (c is ClassProxy && c.ClassType == ClassType.Delegate) { -// description = ambience.Convert(ParserService.GetClass(c.FullyQualifiedName)); -// c = null; -// } - if (documentation == null) { - return ""; - } // don't give a description string, if no documentation or description is provided - if (description.Length + documentation.Length == 0) { + if (description.Length == 0 && (documentation == null || documentation.Length == 0)) { return ""; } - if (!convertedDocumentation) { + if (!convertedDocumentation && documentation != null) { convertedDocumentation = true; - try { - documentation = GetDocumentation(documentation); - // new (by G.B.) - // XmlDocument doc = new XmlDocument(); - // doc.LoadXml("" + documentation + ""); - // XmlNode root = doc.DocumentElement; - // XmlNode paramDocu = root.SelectSingleNode("summary"); - // documentation = paramDocu.InnerXml; - } catch (Exception e) { - Console.WriteLine(e.ToString()); - } + documentation = GetDocumentation(documentation); } return description + (overloads > 0 ? " " + StringParser.Parse("${res:ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor.CodeCompletionData.OverloadsCounter}", new string[,] {{"NumOverloads", overloads.ToString()}}) : String.Empty) + "\n" + documentation;