diff --git a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs index 9808062ce8..118372a089 100644 --- a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs +++ b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs @@ -534,6 +534,7 @@ namespace ICSharpCode.Core builder.Append(""); } + /* for (int i = 0; i < returnType.PointerNestingLevel; ++i) { builder.Append('*'); } @@ -545,6 +546,7 @@ namespace ICSharpCode.Core } 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 0a81ba8ddf..d004466e8e 100644 --- a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs +++ b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs @@ -504,6 +504,7 @@ namespace VBNetBinding builder.Append(""); } + /* for (int i = 0; i < returnType.PointerNestingLevel; ++i) { builder.Append('*'); } @@ -515,6 +516,7 @@ namespace VBNetBinding } builder.Append(')'); } + */ return builder.ToString(); } diff --git a/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj b/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj index 01516908e1..1c99330c6b 100644 --- a/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj +++ b/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj @@ -359,7 +359,6 @@ - UserControl @@ -641,6 +640,9 @@ + + + diff --git a/src/Main/Base/Project/Src/Dom/IClass.cs b/src/Main/Base/Project/Src/Dom/IClass.cs index 9713fb56f2..e3ebf0171e 100644 --- a/src/Main/Base/Project/Src/Dom/IClass.cs +++ b/src/Main/Base/Project/Src/Dom/IClass.cs @@ -19,6 +19,18 @@ namespace ICSharpCode.SharpDevelop.Dom get; } + /// + /// The default return type to use for this class. + /// + IReturnType DefaultReturnType { get; } + + /// + /// The fully qualified name in the internal .NET notation (with `1 for generic types) + /// + string DotNetName { + get; + } + string Name { get; } @@ -86,14 +98,15 @@ namespace ICSharpCode.SharpDevelop.Dom get; } - bool IsTypeInInheritanceTree(IClass possibleBaseClass); + IClass GetInnermostClass(int caretLine, int caretColumn); + List GetAccessibleTypes(IClass callingClass); - IMember SearchMember(string memberName); + bool IsTypeInInheritanceTree(IClass possibleBaseClass); - IClass GetInnermostClass(int caretLine, int caretColumn); + //IMember SearchMember(string memberName); - ArrayList GetAccessibleTypes(IClass callingClass); + /* ArrayList GetAccessibleMembers(IClass callingClass, bool showStatic); - + */ } } diff --git a/src/Main/Base/Project/Src/Dom/IReturnType.cs b/src/Main/Base/Project/Src/Dom/IReturnType.cs index dec54eb660..2958faecee 100644 --- a/src/Main/Base/Project/Src/Dom/IReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/IReturnType.cs @@ -6,9 +6,11 @@ // using System; +using System.Collections.Generic; + namespace ICSharpCode.SharpDevelop.Dom { - public interface IReturnType: IComparable + public interface IReturnType { string FullyQualifiedName { get; @@ -22,18 +24,22 @@ namespace ICSharpCode.SharpDevelop.Dom get; } - int PointerNestingLevel { - get; - } - int ArrayCount { // ArrayDimensions.Length + string DotNetName { get; } + + /// + /// Gets the array ranks of the return type. + /// When the return type is not an array, this property returns null. + /// int[] ArrayDimensions { get; } - object DeclaredIn { - get; - } + List GetMethods(); + List GetProperties(); + List GetFields(); + List GetEvents(); + List GetIndexers(); } } diff --git a/src/Main/Base/Project/Src/Dom/ITypeParameter.cs b/src/Main/Base/Project/Src/Dom/ITypeParameter.cs index 0ad38d04ec..898480d550 100644 --- a/src/Main/Base/Project/Src/Dom/ITypeParameter.cs +++ b/src/Main/Base/Project/Src/Dom/ITypeParameter.cs @@ -16,7 +16,26 @@ namespace ICSharpCode.SharpDevelop.Dom /// public interface ITypeParameter { + /// + /// The name of the type parameter (for example "T") + /// string Name { get; } + + int Index { get; } + + /// + /// The method this type parameter is defined for. + /// This property is null when the type parameter is for a class. + /// + IMethod Method { get; } + + /// + /// The class this type parameter is defined for. + /// When the type parameter is defined for a method, this is the class containing + /// that method. + /// + IClass Class { get; } + // TODO: Constraint } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/AbstractNamedEntity.cs b/src/Main/Base/Project/Src/Dom/Implementations/AbstractNamedEntity.cs index 5f4bdcf885..ac258c521d 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/AbstractNamedEntity.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/AbstractNamedEntity.cs @@ -33,9 +33,13 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public override string DocumentationTag { + public virtual string DotNetName { get { - return "T:" + FullyQualifiedName; + if (this.DeclaringType != null) { + return this.DeclaringType.DotNetName + "." + this.Name; + } else { + return FullyQualifiedName; + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs index d49aece2b4..4563db406e 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs @@ -4,18 +4,22 @@ // // // + using System; +using System.Collections.Generic; namespace ICSharpCode.SharpDevelop.Dom { [Serializable] - public abstract class AbstractReturnType : System.MarshalByRefObject, IReturnType + public abstract class AbstractReturnType : IReturnType { - protected int pointerNestingLevel; - protected int[] arrayDimensions; - protected object declaredin = null; + public abstract List GetMethods(); + public abstract List GetProperties(); + public abstract List GetFields(); + public abstract List GetEvents(); + public abstract List GetIndexers(); + string fullyQualifiedName = null; -// int nameHashCode = -1; public virtual string FullyQualifiedName { get { @@ -23,26 +27,19 @@ namespace ICSharpCode.SharpDevelop.Dom return String.Empty; } return fullyQualifiedName; -// return (string)AbstractNamedEntity.fullyQualifiedNames[nameHashCode]; } set { fullyQualifiedName = value; -// nameHashCode = value.GetHashCode(); -// if (AbstractNamedEntity.fullyQualifiedNames[nameHashCode] == null) { -// AbstractNamedEntity.fullyQualifiedNames[nameHashCode] = value; -// } } } - + public virtual string Name { get { if (FullyQualifiedName == null) { return null; } - int index = FullyQualifiedName.LastIndexOf('.'); + int index = FullyQualifiedName.LastIndexOf('.'); return index < 0 ? FullyQualifiedName : FullyQualifiedName.Substring(index + 1); -// string[] name = FullyQualifiedName.Split(new char[] {'.'}); -// return name[name.Length - 1]; } } @@ -55,54 +52,17 @@ namespace ICSharpCode.SharpDevelop.Dom return index < 0 ? String.Empty : FullyQualifiedName.Substring(0, index); } } - - public virtual int PointerNestingLevel { - get { - return pointerNestingLevel; - } - } - - public int ArrayCount { - get { - return ArrayDimensions.Length; - } - } - - public virtual int[] ArrayDimensions { + + public virtual string DotNetName { get { - if (arrayDimensions == null) return new int[0]; - return arrayDimensions; + return FullyQualifiedName; } } - - public virtual int CompareTo(IReturnType value) { - int cmp; - - if (FullyQualifiedName != null) { - cmp = FullyQualifiedName.CompareTo(value.FullyQualifiedName); - if (cmp != 0) { - return cmp; - } - } - - cmp = (PointerNestingLevel - value.PointerNestingLevel); - if (cmp != 0) { - return cmp; - } - - return DiffUtility.Compare(ArrayDimensions, value.ArrayDimensions); - } - - int IComparable.CompareTo(object value) - { - return CompareTo((IReturnType)value); - } - public virtual object DeclaredIn { + public int[] ArrayDimensions { get { - return declaredin; + return null; } } } - } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs index fc32865d92..856bd6fded 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs @@ -52,6 +52,16 @@ namespace ICSharpCode.SharpDevelop.Dom Modifiers = modifiers; } + IReturnType defaultReturnType; + + public IReturnType DefaultReturnType { + get { + if (defaultReturnType == null) + defaultReturnType = new DefaultReturnType(this); + return defaultReturnType; + } + } + public ICompilationUnit CompilationUnit { get { return compilationUnit; @@ -80,6 +90,22 @@ namespace ICSharpCode.SharpDevelop.Dom } } + public override string DotNetName { + get { + if (typeParameters == null || typeParameters.Count == 0) { + return FullyQualifiedName; + } else { + return FullyQualifiedName + "`" + typeParameters.Count; + } + } + } + + public override string DocumentationTag { + get { + return "T:" + DotNetName; + } + } + public List BaseTypes { get { if (baseTypes == null) { @@ -247,7 +273,6 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public bool IsTypeInInheritanceTree(IClass possibleBaseClass) { if (possibleBaseClass == null) { @@ -267,6 +292,7 @@ namespace ICSharpCode.SharpDevelop.Dom return false; } + /* public IMember SearchMember(string memberName) { if (memberName == null || memberName.Length == 0) { @@ -316,6 +342,7 @@ namespace ICSharpCode.SharpDevelop.Dom } return null; } + */ public IClass GetInnermostClass(int caretLine, int caretColumn) { @@ -331,9 +358,9 @@ namespace ICSharpCode.SharpDevelop.Dom return this; } - public ArrayList GetAccessibleTypes(IClass callingClass) + public List GetAccessibleTypes(IClass callingClass) { - ArrayList types = new ArrayList(); + List types = new List(); bool isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(this); foreach (IClass c in InnerClasses) { @@ -344,28 +371,18 @@ namespace ICSharpCode.SharpDevelop.Dom } IClass baseClass = BaseClass; if (baseClass != null) { - types.AddRange(baseClass.GetAccessibleTypes(callingClass).ToArray()); + types.AddRange(baseClass.GetAccessibleTypes(callingClass)); } return types; } + /* public ArrayList GetAccessibleMembers(IClass callingClass, bool showStatic) { ArrayList members = new ArrayList(); DateTime now = DateTime.Now; - // enums must be handled specially, because there are several things defined we don't want to show - // and enum members have neither the modifier nor the modifier public - /*if (ClassType == ClassType.Enum) { - foreach (IField f in Fields) { - if (f.IsLiteral) { - members.Add(f); - } - } - members.AddRange(ProjectContent.GetClass("System.Enum").GetAccessibleMembers(callingClass, showStatic).ToArray()); - return members; - }*/ bool isClassInInheritanceTree = false; if (callingClass != null) @@ -419,6 +436,7 @@ namespace ICSharpCode.SharpDevelop.Dom return members; } + */ public class ClassInheritanceEnumerator : IEnumerator, IEnumerable { diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs index 8bd72d9234..bf76412be8 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs @@ -20,7 +20,7 @@ namespace ICSharpCode.SharpDevelop.Dom public override string DocumentationTag { get { - return "E:" + this.FullyQualifiedName; + return "E:" + this.DotNetName; } } @@ -64,13 +64,6 @@ namespace ICSharpCode.SharpDevelop.Dom return cmp; } } - - if (ReturnType != null) { - cmp = ReturnType.CompareTo(value.ReturnType); - if (cmp != 0) { - return cmp; - } - } return Region.CompareTo(value.Region); } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs index 36c7b6eb8b..8cc5ccbb08 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs @@ -14,7 +14,7 @@ namespace ICSharpCode.SharpDevelop.Dom { public override string DocumentationTag { get { - return "F:" + this.FullyQualifiedName; + return "F:" + this.DotNetName; } } @@ -52,12 +52,6 @@ namespace ICSharpCode.SharpDevelop.Dom } } - if (ReturnType != null) { - cmp = ReturnType.CompareTo(field.ReturnType); - if (cmp != 0) { - return cmp; - } - } if (Region != null) { return Region.CompareTo(field.Region); } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs index d9f6068865..87fbf97c80 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs @@ -19,7 +19,8 @@ namespace ICSharpCode.SharpDevelop.Dom public override string DocumentationTag { get { - return "P:" + this.FullyQualifiedName; + // TODO: We have to specify the parameters here + return "P:" + this.DotNetName; } } @@ -83,13 +84,6 @@ namespace ICSharpCode.SharpDevelop.Dom } } - if (ReturnType != null) { - cmp = ReturnType.CompareTo(value.ReturnType); - if (cmp != 0) { - return cmp; - } - } - if (Region != null) { cmp = Region.CompareTo(value.Region); if (cmp != 0) { diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs index af56c3c54a..6b6adf7df7 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs @@ -5,6 +5,7 @@ // // using System; +using System.Text; using System.Reflection; using System.Collections.Generic; @@ -14,7 +15,7 @@ namespace ICSharpCode.SharpDevelop.Dom public class Constructor : DefaultMethod { public Constructor(ModifierEnum m, IRegion region, IRegion bodyRegion, IClass declaringType) - : base("#ctor", new ICSharpCode.SharpDevelop.Dom.NRefactoryResolver.ReturnType(declaringType.FullyQualifiedName), + : base("#ctor", declaringType.DefaultReturnType, m, region, bodyRegion, declaringType) { } @@ -35,10 +36,34 @@ namespace ICSharpCode.SharpDevelop.Dom protected IRegion bodyRegion; List parameters = null; + List typeParameters = null; + + public override string DotNetName { + get { + if (typeParameters == null || typeParameters.Count == 0) + return base.DotNetName; + else + return base.DotNetName + "``" + typeParameters.Count; + } + } public override string DocumentationTag { get { - return "M:" + this.FullyQualifiedName; + 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(')'); + } + return b.ToString(); } } @@ -48,6 +73,15 @@ namespace ICSharpCode.SharpDevelop.Dom } } + public virtual List TypeParameters { + get { + if (typeParameters == null) { + typeParameters = new List(); + } + return typeParameters; + } + } + public virtual List Parameters { get { if (parameters == null) { @@ -104,13 +138,6 @@ namespace ICSharpCode.SharpDevelop.Dom } } - if (ReturnType != null) { - cmp = ReturnType.CompareTo(value.ReturnType); - if (cmp != 0) { - return cmp; - } - } - if (Region != null) { cmp = Region.CompareTo(value.Region); if (cmp != 0) { diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs index 53dd36e93d..5cf977c2c8 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs @@ -123,10 +123,6 @@ namespace ICSharpCode.SharpDevelop.Dom return cmp; } } - if (ReturnType != null) { - if(0 != (cmp = ReturnType.CompareTo(value.ReturnType))) - return cmp; - } if(0 != (cmp = (int)(Modifier - value.Modifier))) return cmp; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs index b7b85cf498..8c047ffce7 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs @@ -24,7 +24,7 @@ namespace ICSharpCode.SharpDevelop.Dom { public override string DocumentationTag { get { - return "P:" + this.FullyQualifiedName; + return "P:" + this.DotNetName; } } @@ -109,11 +109,6 @@ namespace ICSharpCode.SharpDevelop.Dom { } } - if (ReturnType != null) { - if(0 != (cmp = ReturnType.CompareTo(value.ReturnType))) - return cmp; - } - if(0 != (cmp = Region.CompareTo(value.Region))) return cmp; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs new file mode 100644 index 0000000000..a9ae53fa42 --- /dev/null +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs @@ -0,0 +1,93 @@ +// +// +// +// +// +// + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.SharpDevelop.Dom +{ + [Serializable] + public class DefaultReturnType : AbstractReturnType + { + IClass c; + + public DefaultReturnType(IClass c) + { + if (c == null) + throw new ArgumentNullException("c"); + this.c = c; + } + + public override List GetMethods() + { + List l = new List(); + foreach (IClass bc in c.ClassInheritanceTree) { + l.AddRange(bc.Methods); + } + return l; + } + + public override List GetProperties() + { + List l = new List(); + foreach (IClass bc in c.ClassInheritanceTree) { + l.AddRange(bc.Properties); + } + return l; + } + + public override List GetFields() + { + List l = new List(); + foreach (IClass bc in c.ClassInheritanceTree) { + l.AddRange(bc.Fields); + } + return l; + } + + public override List GetEvents() + { + List l = new List(); + foreach (IClass bc in c.ClassInheritanceTree) { + l.AddRange(bc.Events); + } + return l; + } + + public override List GetIndexers() + { + return c.Indexer; + } + + public override string FullyQualifiedName { + get { + return c.FullyQualifiedName; + } + set { + + } + } + + public override string Name { + get { + return c.Name; + } + } + + public override string Namespace { + get { + return c.Namespace; + } + } + + public override string DotNetName { + get { + return c.DotNetName; + } + } + } +} diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs index 136542f190..7101f9e985 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs @@ -24,9 +24,42 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public DefaultTypeParameter(string name) + int index; + + public int Index { + get { + return index; + } + } + + IMethod method; + IClass targetClass; + + public IMethod Method { + get { + return method; + } + } + + public IClass Class { + get { + return targetClass; + } + } + + public DefaultTypeParameter(IMethod method, string name, int index) + { + this.method = method; + this.targetClass = method.DeclaringType; + this.name = name; + this.index = index; + } + + public DefaultTypeParameter(IClass targetClass, string name, int index) { + this.targetClass = targetClass; this.name = name; + this.index = index; } public DefaultTypeParameter(Type type) diff --git a/src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs new file mode 100644 index 0000000000..52a1415dd4 --- /dev/null +++ b/src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs @@ -0,0 +1,90 @@ +// +// +// +// +// +// + +using System; +using System.Collections.Generic; +using ICSharpCode.Core; + +namespace ICSharpCode.SharpDevelop.Dom +{ + /// + /// Context used to resolve lazy return types. + /// + public interface IResolveContext + { + IReturnType Resolve(object data); + } + + /// + /// The LazyReturnType is the most used return type: + /// It is not bound to a class, but only resolved when necessary. + /// + public sealed class LazyReturnType : ProxyReturnType + { + IResolveContext context; + object data; + + public LazyReturnType(IResolveContext context, object data) + { + if (context == null) + throw new ArgumentNullException("context"); + if (data == null) + throw new ArgumentNullException("data"); + this.context = context; + this.data = data; + } + + public override IReturnType BaseType { + get { + return context.Resolve(data); + } + } + + public override string ToString() + { + return String.Format("[LazyReturnType: context = {0}, data = {1}]", + context, + data); + } + } + + public class GetClassResolveContext : IResolveContext + { + IProjectContent content; + + public GetClassResolveContext(IProjectContent content) + { + this.content = content; + } + + public IReturnType Resolve(object data) + { + IClass c = content.GetClass((string)data); + return (c != null) ? c.DefaultReturnType : null; + } + } + + public class SearchClassResolveContext : IResolveContext + { + IClass declaringClass; + int caretLine; + int caretColumn; + + public SearchClassResolveContext(IClass declaringClass, int caretLine, int caretColumn) + { + this.declaringClass = declaringClass; + this.caretLine = caretLine; + this.caretColumn = caretColumn; + } + + public IReturnType Resolve(object data) + { + IClass c = declaringClass.ProjectContent.SearchType((string)data, declaringClass, caretLine, caretColumn); + return (c != null) ? c.DefaultReturnType : null; + } + } +} diff --git a/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs new file mode 100644 index 0000000000..6eba342e9a --- /dev/null +++ b/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs @@ -0,0 +1,89 @@ +// +// +// +// +// +// + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.SharpDevelop.Dom +{ + [Serializable] + public abstract class ProxyReturnType : IReturnType + { + public abstract IReturnType BaseType { + get; + } + + public virtual string FullyQualifiedName { + get { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.FullyQualifiedName : null; + } + } + + public virtual string Name { + get { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.Name : null; + } + } + + public virtual string Namespace { + get { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.Namespace : null; + } + } + + public virtual string DotNetName { + get { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.DotNetName : null; + } + } + + /// + /// Gets the array ranks of the return type. + /// When the return type is not an array, this property returns null. + /// + public virtual int[] ArrayDimensions { + get { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.ArrayDimensions : null; + } + } + + public List GetMethods() + { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.GetMethods() : new List(); + } + + public List GetProperties() + { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.GetProperties() : new List(); + } + + public List GetFields() + { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.GetFields() : new List(); + } + + public List GetEvents() + { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.GetEvents() : new List(); + } + + public List GetIndexers() + { + IReturnType baseType = BaseType; + return (baseType != null) ? baseType.GetIndexers() : new List(); + } + } +} diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs index 1057c6a76f..a6a548963c 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs @@ -214,7 +214,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } cu.Classes.Add(c); } - DefaultMethod invokeMethod = new DefaultMethod("Invoke", new ReturnType(delegateDeclaration.ReturnType), ConvertModifier(delegateDeclaration.Modifier), null, null, c); + DefaultMethod invokeMethod = new DefaultMethod("Invoke", CreateReturnType(delegateDeclaration.ReturnType), ConvertModifier(delegateDeclaration.Modifier), null, null, c); c.Methods.Add(invokeMethod); return c; } @@ -223,20 +223,18 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver { DefaultRegion region = GetRegion(methodDeclaration.StartLocation, methodDeclaration.EndLocation); DefaultRegion bodyRegion = GetRegion(methodDeclaration.EndLocation, methodDeclaration.Body != null ? methodDeclaration.Body.EndLocation : new Point(-1, -1)); - ReturnType type = new ReturnType(methodDeclaration.TypeReference); + IReturnType type = CreateReturnType(methodDeclaration.TypeReference); DefaultClass c = GetCurrentClass(); DefaultMethod method = new DefaultMethod(methodDeclaration.Name, type, ConvertModifier(methodDeclaration.Modifier), region, bodyRegion, GetCurrentClass()); method.Attributes.AddRange(VisitAttributes(methodDeclaration.Attributes)); - List parameters = new List(); if (methodDeclaration.Parameters != null) { foreach (AST.ParameterDeclarationExpression par in methodDeclaration.Parameters) { - ReturnType parType = new ReturnType(par.TypeReference); + IReturnType parType = CreateReturnType(par.TypeReference); DefaultParameter p = new DefaultParameter(par.ParameterName, parType, new DefaultRegion(par.StartLocation, methodDeclaration.Body.EndLocation)); - parameters.Add(p); + method.Parameters.Add(p); } } - method.Parameters = parameters; c.Methods.Add(method); return null; } @@ -249,15 +247,13 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver Constructor constructor = new Constructor(ConvertModifier(constructorDeclaration.Modifier), region, bodyRegion, GetCurrentClass()); constructor.Attributes.AddRange(VisitAttributes(constructorDeclaration.Attributes)); - List parameters = new List(); if (constructorDeclaration.Parameters != null) { foreach (AST.ParameterDeclarationExpression par in constructorDeclaration.Parameters) { - ReturnType parType = new ReturnType(par.TypeReference); + IReturnType parType = CreateReturnType(par.TypeReference); DefaultParameter p = new DefaultParameter(par.ParameterName, parType, new DefaultRegion(par.StartLocation, constructorDeclaration.Body.EndLocation)); - parameters.Add(p); + constructor.Parameters.Add(p); } } - constructor.Parameters = parameters; c.Methods.Add(constructor); return null; } @@ -284,11 +280,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver for (int i = 0; i < fieldDeclaration.Fields.Count; ++i) { AST.VariableDeclaration field = (AST.VariableDeclaration)fieldDeclaration.Fields[i]; - ReturnType retType; + IReturnType retType; if (c.ClassType == ClassType.Enum) - retType = new ReturnType(c.FullyQualifiedName); + retType = c.DefaultReturnType; else - retType = new ReturnType(fieldDeclaration.GetTypeForField(i)); + retType = CreateReturnType(fieldDeclaration.GetTypeForField(i)); DefaultField f = new DefaultField(retType, field.Name, ConvertModifier(fieldDeclaration.Modifier), region, c); f.Attributes.AddRange(VisitAttributes(fieldDeclaration.Attributes)); if (c.ClassType == ClassType.Enum) { @@ -306,7 +302,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver DefaultRegion region = GetRegion(propertyDeclaration.StartLocation, propertyDeclaration.EndLocation); DefaultRegion bodyRegion = GetRegion(propertyDeclaration.BodyStart, propertyDeclaration.BodyEnd); - ReturnType type = new ReturnType(propertyDeclaration.TypeReference); + IReturnType type = CreateReturnType(propertyDeclaration.TypeReference); DefaultClass c = GetCurrentClass(); DefaultProperty property = new DefaultProperty(propertyDeclaration.Name, type, ConvertModifier(propertyDeclaration.Modifier), region, bodyRegion, GetCurrentClass()); @@ -319,7 +315,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver { DefaultRegion region = GetRegion(eventDeclaration.StartLocation, eventDeclaration.EndLocation); DefaultRegion bodyRegion = GetRegion(eventDeclaration.BodyStart, eventDeclaration.BodyEnd); - ReturnType type = new ReturnType(eventDeclaration.TypeReference); + IReturnType type = CreateReturnType(eventDeclaration.TypeReference); DefaultClass c = GetCurrentClass(); DefaultEvent e = null; @@ -342,11 +338,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver DefaultRegion region = GetRegion(indexerDeclaration.StartLocation, indexerDeclaration.EndLocation); DefaultRegion bodyRegion = GetRegion(indexerDeclaration.BodyStart, indexerDeclaration.BodyEnd); List parameters = new List(); - DefaultIndexer i = new DefaultIndexer(new ReturnType(indexerDeclaration.TypeReference), parameters, ConvertModifier(indexerDeclaration.Modifier), region, bodyRegion, GetCurrentClass()); + DefaultIndexer i = new DefaultIndexer(CreateReturnType(indexerDeclaration.TypeReference), parameters, ConvertModifier(indexerDeclaration.Modifier), region, bodyRegion, GetCurrentClass()); i.Attributes.AddRange(VisitAttributes(indexerDeclaration.Attributes)); if (indexerDeclaration.Parameters != null) { foreach (AST.ParameterDeclarationExpression par in indexerDeclaration.Parameters) { - ReturnType parType = new ReturnType(par.TypeReference); + IReturnType parType = CreateReturnType(par.TypeReference); DefaultParameter p = new DefaultParameter(par.ParameterName, parType, new DefaultRegion(par.StartLocation, indexerDeclaration.EndLocation)); parameters.Add(p); } @@ -355,5 +351,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver c.Indexer.Add(i); return null; } + + IReturnType CreateReturnType(AST.TypeReference reference) + { + return null; + } } } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs index c94b51b1d4..c1fddc2a2e 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs @@ -147,10 +147,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver IReturnType returnType; if (fieldReferenceExpression.FieldName == null || fieldReferenceExpression.FieldName == "") { if (fieldReferenceExpression.TargetObject is TypeReferenceExpression) { - returnType = new ReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference); + // TODO: !!! + /*returnType = new ReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference); IClass c = projectContent.GetClass(returnType.FullyQualifiedName); if (c != null) return new TypeResolveResult(callingClass, callingMember, returnType, c); + */ } } returnType = fieldReferenceExpression.TargetObject.AcceptVisitor(typeVisitor, null) as IReturnType; @@ -164,7 +166,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } IClass c = SearchType(name, this.CallingClass, this.CompilationUnit); if (c != null) { - return new TypeResolveResult(callingClass, callingMember, new ReturnType(c.FullyQualifiedName), c); + return new TypeResolveResult(callingClass, callingMember, c.DefaultReturnType, c); } return null; } @@ -182,15 +184,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } IReturnType type = expr.AcceptVisitor(typeVisitor, null) as IReturnType; - if (type == null || type.FullyQualifiedName == "" || type.PointerNestingLevel != 0) { + if (type == null || type.FullyQualifiedName == "") { return null; } - if (expr is ObjectCreateExpression && type.ArrayCount == 0) { - IClass c = projectContent.GetClass(type.FullyQualifiedName); - if (c == null) - return null; - foreach (IMethod m in c.Methods) { - if (m.IsConstructor) + if (expr is ObjectCreateExpression) { + foreach (IMethod m in type.GetMethods()) { + if (m.IsConstructor && !m.IsStatic) return CreateMemberResolveResult(m); } return null; @@ -200,13 +199,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver IReturnType FixType(IReturnType type) { - if (type == null) - return null; - IClass returnClass = SearchType(type.FullyQualifiedName, callingClass, cu); - if (returnClass != null && returnClass.FullyQualifiedName != type.FullyQualifiedName) - return new ReturnType(returnClass.FullyQualifiedName, type.ArrayDimensions, type.PointerNestingLevel); - else - return type; + return type; } #region Resolve Identifier @@ -229,23 +222,25 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver return new LocalResolveResult(callingMember, field, true); } } - IMember member = GetMember(callingClass, identifier); - if (member != null) { - return CreateMemberResolveResult(member); - } - ResolveResult result = ResolveMethod(callingClass, identifier); - if (result != null) - return result; - - IClass c = SearchType(identifier, this.CallingClass, cu); - if (c != null) { - return new TypeResolveResult(callingClass, callingMember, new ReturnType(c.FullyQualifiedName), c); + if (callingClass != null) { + IMember member = GetMember(callingClass.DefaultReturnType, identifier); + if (member != null) { + return CreateMemberResolveResult(member); + } + ResolveResult result = ResolveMethod(callingClass.DefaultReturnType, identifier); + if (result != null) + return result; + + IClass c = SearchType(identifier, callingClass, cu); + if (c != null) { + return new TypeResolveResult(callingClass, callingMember, c.DefaultReturnType, c); + } } // try if there exists a static member in outer classes named typeName List classes = cu.GetOuterClasses(caretLine, caretColumn); foreach (IClass c2 in classes) { - member = GetMember(c2, identifier); + IMember member = GetMember(c2.DefaultReturnType, identifier); if (member != null && member.IsStatic) { return new MemberResolveResult(callingClass, callingMember, member); } @@ -263,25 +258,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver #region ResolveMethod ResolveResult ResolveMethod(IReturnType type, string identifier) { - if (type == null || type.PointerNestingLevel != 0) - return null; - IClass curType; - if (type.ArrayDimensions != null && type.ArrayDimensions.Length > 0) - curType = SearchType("System.Array", null, null); - else - curType = SearchType(type.FullyQualifiedName, null, null); - return ResolveMethod(curType, identifier); - } - - ResolveResult ResolveMethod(IClass c, string identifier) - { - if (c == null) + if (type == null) return null; - foreach (IClass curType in c.ClassInheritanceTree) { - foreach (IMethod method in c.Methods) { - if (IsSameName(identifier, method.Name)) - return new MethodResolveResult(callingClass, callingMember, c, identifier); - } + foreach (IMethod method in type.GetMethods()) { + if (IsSameName(identifier, method.Name)) + return new MethodResolveResult(callingClass, callingMember, method.DeclaringType, identifier); } return null; } @@ -409,45 +390,21 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver /// public ArrayList SearchMethod(IReturnType type, string memberName) { - if (type == null || type.PointerNestingLevel != 0) { - return new ArrayList(1); - } - IClass curType; - if (type.ArrayDimensions != null && type.ArrayDimensions.Length > 0) { - curType = SearchType("System.Array", null, null); - } else { - curType = SearchType(type.FullyQualifiedName, null, null); - } - return SearchMethod(new ArrayList(), curType, memberName); - } - - /// - /// Gets the list of methods on the class that have the specified name. - /// - public ArrayList SearchMethod(IClass type, string memberName) - { - return SearchMethod(new ArrayList(), type, memberName); - } - - ArrayList SearchMethod(ArrayList methods, IClass curType, string memberName) - { - if (curType == null) + ArrayList methods = new ArrayList(); + if (type == null) return methods; - bool isClassInInheritanceTree = false; - if (callingClass != null) - isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(curType); - foreach (IMethod m in curType.Methods) { - if (IsSameName(m.Name, memberName) && - m.IsAccessible(callingClass, isClassInInheritanceTree) && - !((m.Modifiers & ModifierEnum.Override) == ModifierEnum.Override)) { + //bool isClassInInheritanceTree = false; + //if (callingClass != null) + // isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(curType); + + foreach (IMethod m in type.GetMethods()) { + if (IsSameName(m.Name, memberName) + // && m.IsAccessible(callingClass, isClassInInheritanceTree) + ) { methods.Add(m); } } - IClass baseClass = curType.BaseClass; - if (baseClass != null) { - return SearchMethod(methods, baseClass, memberName); - } return methods; } #endregion @@ -484,79 +441,43 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver // no methods or indexer public IReturnType SearchMember(IReturnType type, string memberName) { - if (type == null || memberName == null || memberName == "") { - return null; - } - if (type.PointerNestingLevel != 0) { - return null; - } - IClass curType; - if (type.ArrayDimensions != null && type.ArrayDimensions.Length > 0) { - curType = SearchType("System.Array", null, null); - } else { - curType = SearchType(type.FullyQualifiedName, callingClass, cu); - } - return SearchMember(curType, memberName); - } - - public IMember GetMember(IReturnType type, string memberName) - { - if (type == null || memberName == null || memberName == "") { - return null; - } - if (type.PointerNestingLevel != 0) { - return null; - } - IClass curType; - if (type.ArrayDimensions != null && type.ArrayDimensions.Length > 0) { - curType = SearchType("System.Array", null, null); - } else { - curType = SearchType(type.FullyQualifiedName, callingClass, cu); - } - return GetMember(curType, memberName); - } - - public IReturnType SearchMember(IClass curType, string memberName) - { - if (curType == null) + if (type == null) return null; - bool isClassInInheritanceTree = false; - if (callingClass != null) - isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(curType); - foreach (IClass c in curType.InnerClasses) { - if (IsSameName(c.Name, memberName) && c.IsAccessible(callingClass, isClassInInheritanceTree)) { - return new ReturnType(c.FullyQualifiedName); - } - } - IMember member = GetMember(curType, memberName); + //bool isClassInInheritanceTree = false; + //if (callingClass != null) + // isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(curType); + //foreach (IClass c in curType.InnerClasses) { + // if (IsSameName(c.Name, memberName) && c.IsAccessible(callingClass, isClassInInheritanceTree)) { + // return new ReturnType(c.FullyQualifiedName); + // } + //} + IMember member = GetMember(type, memberName); if (member == null) return null; else return member.ReturnType; } - private IMember GetMember(IClass c, string memberName) + public IMember GetMember(IReturnType type, string memberName) { - if (c == null) + if (type == null) return null; - bool isClassInInheritanceTree = false; - if (callingClass != null) - isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(c); - foreach (IClass curType in c.ClassInheritanceTree) { - foreach (IProperty p in curType.Properties) { - if (IsSameName(p.Name, memberName) && p.IsAccessible(callingClass, isClassInInheritanceTree)) { - return p; - } + //bool isClassInInheritanceTree = false; + //if (callingClass != null) + // isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(c); + foreach (IProperty p in type.GetProperties()) { + if (IsSameName(p.Name, memberName)) { + return p; } - foreach (IField f in curType.Fields) { - if (IsSameName(f.Name, memberName) && f.IsAccessible(callingClass, isClassInInheritanceTree)) { - return f; - } + } + foreach (IField f in type.GetFields()) { + if (IsSameName(f.Name, memberName)) { + return f; } - foreach (IEvent e in curType.Events) { - if (IsSameName(e.Name, memberName) && e.IsAccessible(callingClass, isClassInInheritanceTree)) { - return e; - } + } + foreach (IEvent e in type.GetEvents()) { + if (IsSameName(e.Name, memberName)) { + return e; } } return null; @@ -594,7 +515,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } // try if there exists a nonstatic member named typeName - IReturnType t = SearchMember(callingClass, typeName); + IReturnType t = SearchMember(callingClass.DefaultReturnType, typeName); if (t != null) { return t; } @@ -602,7 +523,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver // try if there exists a static member in outer classes named typeName List classes = cu.GetOuterClasses(caretLine, caretColumn); foreach (IClass c in classes) { - IMember member = GetMember(c, typeName); + IMember member = GetMember(c.DefaultReturnType, typeName); if (member != null && member.IsStatic) { return member.ReturnType; } @@ -631,9 +552,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } IClass c = SearchType(v.TypeRef.SystemType, callingClass, cu); if (c != null) { - return new ReturnType(c.FullyQualifiedName, v.TypeRef.RankSpecifier, v.TypeRef.PointerNestingLevel); + return c.DefaultReturnType; } else { - return new ReturnType(v.TypeRef); + //return new ReturnType(v.TypeRef); + return null; } } @@ -711,17 +633,17 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver IMethod method = callingMember as IMethod; if (method != null) { foreach (IParameter p in method.Parameters) { - result.Add(new DefaultField(new ReturnType(p.ReturnType.Name, p.ReturnType.ArrayDimensions, p.ReturnType.PointerNestingLevel), p.Name, ModifierEnum.None, method.Region, callingClass)); + result.Add(new DefaultField(p.ReturnType, p.Name, ModifierEnum.None, method.Region, callingClass)); } } result.AddRange(projectContent.GetNamespaceContents(callingClass.Namespace)); bool inStatic = true; if (callingMember != null) inStatic = callingMember.IsStatic; - result.AddRange(callingClass.GetAccessibleMembers(callingClass, inStatic).ToArray()); - if (inStatic == false) { - result.AddRange(callingClass.GetAccessibleMembers(callingClass, !inStatic).ToArray()); - } + //result.AddRange(callingClass.GetAccessibleMembers(callingClass, inStatic).ToArray()); + //if (inStatic == false) { + // result.AddRange(callingClass.GetAccessibleMembers(callingClass, !inStatic).ToArray()); + //} } } foreach (string name in lookupTableVisitor.variables.Keys) { @@ -731,7 +653,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (IsInside(new Point(caretColumn, caretLine), v.StartPos, v.EndPos)) { // LocalLookupVariable in no known Type in DisplayBindings.TextEditor // so add Field for the Variables - result.Add(new DefaultField(new ReturnType(v.TypeRef), name, ModifierEnum.None, new DefaultRegion(v.StartPos, v.EndPos), callingClass)); + //result.Add(new DefaultField(new ReturnType(v.TypeRef), name, ModifierEnum.None, new DefaultRegion(v.StartPos, v.EndPos), callingClass)); break; } } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/ReturnType.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/ReturnType.cs deleted file mode 100644 index 3afb83c284..0000000000 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/ReturnType.cs +++ /dev/null @@ -1,50 +0,0 @@ -// created on 04.08.2003 at 18:08 - -using ICSharpCode.SharpDevelop.Dom; - -namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver -{ - public class ReturnType : AbstractReturnType - { - public new int PointerNestingLevel { - get { - return base.pointerNestingLevel; - } - set { - base.pointerNestingLevel = value; - } - } - - public new int[] ArrayDimensions { - get { - return base.arrayDimensions; - } - set { - base.arrayDimensions = value; - } - } - - public ReturnType(string fullyQualifiedName) - { - base.FullyQualifiedName = fullyQualifiedName; - } - - public ReturnType(string fullyQualifiedName, int[] arrayDimensions, int pointerNestingLevel) - { - this.FullyQualifiedName = fullyQualifiedName; - this.arrayDimensions = arrayDimensions; - this.pointerNestingLevel = pointerNestingLevel; - } - - public ReturnType(ICSharpCode.NRefactory.Parser.AST.TypeReference type) - { - base.FullyQualifiedName = type.SystemType; - base.arrayDimensions = type.RankSpecifier == null ? new int[] { } : type.RankSpecifier; - base.pointerNestingLevel = type.PointerNestingLevel; - } - public ReturnType Clone() - { - return new ReturnType(FullyQualifiedName, arrayDimensions, pointerNestingLevel); - } - } -} diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs index 9a512efbe6..25ec9abadf 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs @@ -23,7 +23,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(PrimitiveExpression primitiveExpression, object data) { if (primitiveExpression.Value != null) { - return new ReturnType(primitiveExpression.Value.GetType().FullName); + return ReflectionReturnType(primitiveExpression.Value.GetType()); } return null; } @@ -86,7 +86,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver for (int i = 0; i < types.Length; ++i) { IReturnType type = method.Parameters[i].ReturnType; if (type != null && types[i] != null) { - if (type.CompareTo(types[i]) == 0) + if (type.Equals(types[i])) points += 1; } } @@ -108,7 +108,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (resolver.CallingClass == null) { return null; } - ArrayList methods = resolver.SearchMethod(resolver.CallingClass, id); + ArrayList methods = resolver.SearchMethod(resolver.CallingClass.DefaultReturnType, id); return FindOverload(methods, invocationExpression, data); } // invocationExpression is delegate call @@ -132,7 +132,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver // int. generates a FieldreferenceExpression with TargetObject TypeReferenceExpression and no FieldName if (fieldReferenceExpression.FieldName == null || fieldReferenceExpression.FieldName == "") { if (fieldReferenceExpression.TargetObject is TypeReferenceExpression) { - return new ReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference); + return CreateReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference); } } IReturnType returnType = fieldReferenceExpression.TargetObject.AcceptVisitor(this, data) as IReturnType; @@ -141,11 +141,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (name != null) { string n = resolver.SearchNamespace(name + "." + fieldReferenceExpression.FieldName, null); if (n != null) { - return new ReturnType(n); + return NamespaceReturnType(n); } IClass c = resolver.SearchType(name + "." + fieldReferenceExpression.FieldName, resolver.CallingClass, resolver.CompilationUnit); if (c != null) { - return new ReturnType(c.FullyQualifiedName); + return c.DefaultReturnType; } return null; } @@ -156,6 +156,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(PointerReferenceExpression pointerReferenceExpression, object data) { + return null; + /* ReturnType type = pointerReferenceExpression.TargetObject.AcceptVisitor(this, data) as ReturnType; if (type == null) { return null; @@ -166,6 +168,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver return null; } return resolver.SearchMember(type, pointerReferenceExpression.Identifier); + */ } public override object Visit(IdentifierExpression identifierExpression, object data) @@ -175,18 +178,18 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } string name = resolver.SearchNamespace(identifierExpression.Identifier, resolver.CompilationUnit); if (name != null && name != "") { - return new ReturnType(name); + return NamespaceReturnType(name); } IClass c = resolver.SearchType(identifierExpression.Identifier, resolver.CallingClass, resolver.CompilationUnit); if (c != null) { - return new ReturnType(c.FullyQualifiedName); + return c.DefaultReturnType;; } return resolver.DynamicLookup(identifierExpression.Identifier); } public override object Visit(TypeReferenceExpression typeReferenceExpression, object data) { - return new ReturnType(typeReferenceExpression.TypeReference); + return CreateReturnType(typeReferenceExpression.TypeReference); } public override object Visit(UnaryOperatorExpression unaryOperatorExpression, object data) @@ -194,7 +197,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (unaryOperatorExpression == null) { return null; } - ReturnType expressionType = unaryOperatorExpression.Expression.AcceptVisitor(this, data) as ReturnType; + IReturnType expressionType = unaryOperatorExpression.Expression.AcceptVisitor(this, data) as IReturnType; // TODO: Little bug: unary operator MAY change the return type, // but that is only a minor issue switch (unaryOperatorExpression.Op) { @@ -213,10 +216,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver case UnaryOperatorType.PostDecrement: break; case UnaryOperatorType.Star: // dereference - --expressionType.PointerNestingLevel; + //--expressionType.PointerNestingLevel; break; case UnaryOperatorType.BitWiseAnd: // get reference - ++expressionType.PointerNestingLevel; + //++expressionType.PointerNestingLevel; break; case UnaryOperatorType.None: break; @@ -231,12 +234,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(SizeOfExpression sizeOfExpression, object data) { - return new ReturnType("System.Int32"); + return ReflectionReturnType(typeof(int)); } public override object Visit(TypeOfExpression typeOfExpression, object data) { - return new ReturnType("System.Type"); + return ReflectionReturnType(typeof(Type)); } public override object Visit(CheckedExpression checkedExpression, object data) @@ -251,18 +254,21 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(CastExpression castExpression, object data) { - return new ReturnType(castExpression.CastTo.Type); + return CreateReturnType(castExpression.CastTo); } public override object Visit(StackAllocExpression stackAllocExpression, object data) { - ReturnType returnType = new ReturnType(stackAllocExpression.TypeReference); + /*ReturnType returnType = new ReturnType(stackAllocExpression.TypeReference); ++returnType.PointerNestingLevel; - return returnType; + return returnType;*/ + return null; } public override object Visit(IndexerExpression indexerExpression, object data) { + return null; + /* IReturnType type = (IReturnType)indexerExpression.TargetObject.AcceptVisitor(this, data); if (type == null) { return null; @@ -290,6 +296,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver 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) @@ -297,7 +304,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (resolver.CallingClass == null) { return null; } - return new ReturnType(resolver.CallingClass.FullyQualifiedName); + return resolver.CallingClass.DefaultReturnType; } public override object Visit(ThisReferenceExpression thisReferenceExpression, object data) @@ -305,7 +312,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (resolver.CallingClass == null) { return null; } - return new ReturnType(resolver.CallingClass.FullyQualifiedName); + return resolver.CallingClass.DefaultReturnType; } public override object Visit(BaseReferenceExpression baseReferenceExpression, object data) @@ -317,7 +324,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (baseClass == null) { return null; } - return new ReturnType(baseClass.FullyQualifiedName); + return baseClass.DefaultReturnType; } public override object Visit(ObjectCreateExpression objectCreateExpression, object data) @@ -326,18 +333,21 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver IClass c = resolver.SearchType(name, resolver.CallingClass, resolver.CompilationUnit); if (c != null) name = c.FullyQualifiedName; - return new ReturnType(name, objectCreateExpression.CreateType.RankSpecifier, objectCreateExpression.CreateType.PointerNestingLevel); + return c.DefaultReturnType; + //return new ReturnType(name, objectCreateExpression.CreateType.RankSpecifier, objectCreateExpression.CreateType.PointerNestingLevel); } public override object Visit(ArrayCreateExpression arrayCreateExpression, object data) { - ReturnType type = new ReturnType(arrayCreateExpression.CreateType); + IReturnType type = CreateReturnType(arrayCreateExpression.CreateType); + /* if (arrayCreateExpression.Parameters != null && arrayCreateExpression.Parameters.Count > 0) { int[] newRank = new int[arrayCreateExpression.Rank.Length + 1]; newRank[0] = arrayCreateExpression.Parameters.Count - 1; Array.Copy(type.ArrayDimensions, 0, newRank, 1, type.ArrayDimensions.Length); type.ArrayDimensions = newRank; } + */ return type; } @@ -352,5 +362,20 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver // no calls allowed !!! return null; } + + IReturnType CreateReturnType(TypeReference reference) + { + return null; + } + + IReturnType NamespaceReturnType(string namespaceName) + { + return null; + } + + IReturnType ReflectionReturnType(Type t) + { + return null; + } } } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs index 2dbd986e2c..84b8f60bb3 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs @@ -20,7 +20,7 @@ namespace ICSharpCode.SharpDevelop.Dom BindingFlags flags = BindingFlags.Instance | BindingFlags.Static | - BindingFlags.NonPublic | + //BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Public; @@ -128,12 +128,6 @@ namespace ICSharpCode.SharpDevelop.Dom return type.IsSubclassOf(typeof(Delegate)) && type != typeof(MulticastDelegate); } - public override string DocumentationTag { - get { - return "T:" + type.FullName; - } - } - public ReflectionClass(ICompilationUnit compilationUnit, Type type, IClass declaringType) : base(compilationUnit, declaringType) { this.type = type; diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs index fa2cff5da5..fdb0ea1ae1 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs @@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom public override IReturnType ReturnType { get { - return new ReflectionReturnType(eventInfo.EventHandlerType); + return ReflectionReturnType.Create(this, eventInfo.EventHandlerType); } set { } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs index 785c61b9ed..6bb86404df 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs @@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom FieldInfo fieldInfo; public override IReturnType ReturnType { get { - return new ReflectionReturnType(fieldInfo.FieldType); + return ReflectionReturnType.Create(this, fieldInfo.FieldType); } set { } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs index 6aa4709f0f..e890980e0e 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs @@ -20,7 +20,7 @@ namespace ICSharpCode.SharpDevelop.Dom public override IReturnType ReturnType { get { - return new ReflectionReturnType(propertyInfo.PropertyType); + return ReflectionReturnType.Create(this, propertyInfo.PropertyType); } set { } @@ -30,7 +30,7 @@ namespace ICSharpCode.SharpDevelop.Dom get { List parameters = new List(); foreach (ParameterInfo parameterInfo in propertyInfo.GetIndexParameters()) { - parameters.Add(new ReflectionParameter(parameterInfo)); + parameters.Add(new ReflectionParameter(parameterInfo, DeclaringType.ProjectContent)); } return parameters; } @@ -38,20 +38,6 @@ namespace ICSharpCode.SharpDevelop.Dom } } - string GetIndexerName(PropertyInfo propertyInfo) - { - StringBuilder propertyName = new StringBuilder("Item("); - ParameterInfo[] p = propertyInfo.GetIndexParameters(); - for (int i = 0; i < p.Length; ++i) { - propertyName.Append(p[i].ParameterType.FullName); - if (i + 1 < p.Length) { - propertyName.Append(','); - } - } - propertyName.Append(')'); - return propertyName.ToString(); - } - public ReflectionIndexer(PropertyInfo propertyInfo, IClass declaringType) : base(declaringType) { this.propertyInfo = propertyInfo; diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs index 7879b40f99..e957fec5f1 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs @@ -14,7 +14,7 @@ using System.Xml; namespace ICSharpCode.SharpDevelop.Dom { [Serializable] - public class ReflectionMethod : DefaultMethod + public class ReflectionMethod : DefaultMethod { MethodBase methodBase; @@ -28,8 +28,8 @@ namespace ICSharpCode.SharpDevelop.Dom public override IReturnType ReturnType { get { if (methodBase is MethodInfo) { - return new ReflectionReturnType(((MethodInfo)methodBase).ReturnType); - } + return ReflectionReturnType.Create(this, ((MethodInfo)methodBase).ReturnType); + } return null; } set { @@ -40,7 +40,7 @@ namespace ICSharpCode.SharpDevelop.Dom get { List parameters = new List(); foreach (ParameterInfo paramInfo in methodBase.GetParameters()) { - parameters.Add(new ReflectionParameter(paramInfo)); + parameters.Add(new ReflectionParameter(paramInfo, DeclaringType.ProjectContent)); } return parameters; } @@ -48,29 +48,6 @@ namespace ICSharpCode.SharpDevelop.Dom } } - string GetParamList(MethodBase methodBase) - { - StringBuilder propertyName = new StringBuilder("("); - ParameterInfo[] p = methodBase.GetParameters(); - if (p.Length == 0) { - return String.Empty; - } - for (int i = 0; i < p.Length; ++i) { - propertyName.Append(p[i].ParameterType.FullName); - if (i + 1 < p.Length) { - propertyName.Append(','); - } - } - propertyName.Append(')'); - return propertyName.ToString(); - } - - public override string DocumentationTag { - get { - return "M:" + FullyQualifiedName + GetParamList(methodBase); - } - } - public ReflectionMethod(MethodBase methodBase, IClass declaringType) : base(declaringType, methodBase is ConstructorInfo ? "#ctor" : methodBase.Name) { diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs index 95d5fca73a..c5726575d5 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs @@ -7,6 +7,7 @@ using System; using System.Reflection; using System.Xml; +using ICSharpCode.Core; namespace ICSharpCode.SharpDevelop.Dom { @@ -14,22 +15,24 @@ namespace ICSharpCode.SharpDevelop.Dom public class ReflectionParameter : DefaultParameter { ParameterInfo parameterInfo; + IProjectContent content; + public override IReturnType ReturnType { get { - return new ReflectionReturnType(parameterInfo.ParameterType); + return ReflectionReturnType.Create(content, parameterInfo.ParameterType); } set { } } - public ReflectionParameter(ParameterInfo parameterInfo) : base(parameterInfo.Name) + public ReflectionParameter(ParameterInfo parameterInfo, IProjectContent content) : base(parameterInfo.Name) { this.parameterInfo = parameterInfo; + this.content = content; if (parameterInfo.IsOut) { modifier |= ParameterModifier.Out; } - Type type = parameterInfo.ParameterType; // TODO read param attribute //if (type.IsArray && type != typeof(Array) && Attribute.IsDefined(parameterInfo, typeof(ParamArrayAttribute), true)) { diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs index 5ab0577042..1743567cc2 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs @@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom public override IReturnType ReturnType { get { - return new ReflectionReturnType(propertyInfo.PropertyType); + return ReflectionReturnType.Create(this, propertyInfo.PropertyType); } set { } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs index 79c14379d4..2996027c6d 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs @@ -6,9 +6,29 @@ // using System; using System.Collections; +using ICSharpCode.Core; namespace ICSharpCode.SharpDevelop.Dom { + public static class ReflectionReturnType + { + public static IReturnType Create(IProjectContent content, Type type) + { + string name = type.FullName; + if (name == null) { + // this could be a generic type + return null; + } + return new LazyReturnType(new GetClassResolveContext(content), name); + } + + public static IReturnType Create(IMember member, Type type) + { + return Create(member.DeclaringType.ProjectContent, type); + } + } + + /* [Serializable] public class ReflectionReturnType : AbstractReturnType { @@ -54,4 +74,5 @@ namespace ICSharpCode.SharpDevelop.Dom } } } + */ } diff --git a/src/Main/Base/Project/Src/Dom/ResolveResult.cs b/src/Main/Base/Project/Src/Dom/ResolveResult.cs index 618c9a8e56..93dd4127b8 100644 --- a/src/Main/Base/Project/Src/Dom/ResolveResult.cs +++ b/src/Main/Base/Project/Src/Dom/ResolveResult.cs @@ -71,6 +71,7 @@ namespace ICSharpCode.SharpDevelop.Dom } } + /* public virtual IClass GetResolvedClass(IProjectContent projectContent) { if (resolvedType == null) @@ -79,13 +80,25 @@ namespace ICSharpCode.SharpDevelop.Dom return ProjectContentRegistry.GetMscorlibContent().GetClass("System.Array"); return projectContent.GetClass(resolvedType.FullyQualifiedName); } + */ public virtual ArrayList GetCompletionData(IProjectContent projectContent) { - IClass c = GetResolvedClass(projectContent); - if (c == null) - return null; - return c.GetAccessibleMembers(callingClass, false); + if (resolvedType == null) return null; + ArrayList res = new ArrayList(); + foreach (IMethod m in resolvedType.GetMethods()) { + res.Add(m); + } + foreach (IEvent e in resolvedType.GetEvents()) { + res.Add(e); + } + foreach (IField f in resolvedType.GetFields()) { + res.Add(f); + } + foreach (IProperty p in resolvedType.GetProperties()) { + res.Add(p); + } + return res; } public virtual FilePosition GetDefinitionPosition() @@ -228,19 +241,12 @@ namespace ICSharpCode.SharpDevelop.Dom } } + /* public override IClass GetResolvedClass(IProjectContent projectContent) { return resolvedClass; } - - public override ArrayList GetCompletionData(IProjectContent projectContent) - { - IClass c = GetResolvedClass(projectContent); - if (c == null) - return null; - else - return c.GetAccessibleMembers(this.CallingClass, true); - } + */ public override FilePosition GetDefinitionPosition() { diff --git a/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs b/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs index 0299b8c9f2..a75a9ca747 100644 --- a/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs +++ b/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs @@ -119,7 +119,7 @@ namespace ICSharpCode.Core public string Convert(ParameterInfo param) { - return conv.Convert(new ReflectionParameter(param)); + return conv.Convert(new ReflectionParameter(param, null)); } public ArrayList LinkArrayList { diff --git a/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs b/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs index 5a196abcc6..0483726c5f 100644 --- a/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs +++ b/src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs @@ -267,7 +267,8 @@ namespace ICSharpCode.Core builder.Append(""); } - for (int i = 0; i < returnType.PointerNestingLevel; ++i) { + // TODO: Re-write this! + /*for (int i = 0; i < returnType.PointerNestingLevel; ++i) { builder.Append('*'); } @@ -277,7 +278,7 @@ namespace ICSharpCode.Core builder.Append(','); } builder.Append(']'); - } + }*/ return builder.ToString(); } diff --git a/src/Main/Base/Project/Src/Services/ParserService/CaseSensitiveProjectContent.cs b/src/Main/Base/Project/Src/Services/ParserService/CaseSensitiveProjectContent.cs index 6ee56cfbc9..388c3daf9e 100644 --- a/src/Main/Base/Project/Src/Services/ParserService/CaseSensitiveProjectContent.cs +++ b/src/Main/Base/Project/Src/Services/ParserService/CaseSensitiveProjectContent.cs @@ -380,6 +380,7 @@ namespace ICSharpCode.Core return null; } + /* public ArrayList ListMembers(ArrayList members, IClass curType, IClass callingClass, bool showStatic) { // Console.WriteLine("ListMembers()"); @@ -447,7 +448,7 @@ namespace ICSharpCode.Core return members; } - + */ public Position GetPosition(string fullMemberName) { @@ -480,13 +481,14 @@ namespace ICSharpCode.Core if (i >= name.Length) { return new Position(cu, curClass.Region != null ? curClass.Region.BeginLine : -1, curClass.Region != null ? curClass.Region.BeginColumn : -1); } - IMember member = curClass.SearchMember(name[i]); + return new Position(cu, -1, -1); + // TODO: reimplement this + /*IMember member = curClass.SearchMember(name[i]); if (member == null || member.Region == null) { return new Position(cu, -1, -1); } - return new Position(cu, member.Region.BeginLine, member.Region.BeginColumn); + return new Position(cu, member.Region.BeginLine, member.Region.BeginColumn);*/ } #endregion - } }