From d76c2f86e84a4ec974183fd1c4f7b8ffdd42b8d4 Mon Sep 17 00:00:00 2001 From: Daniel Grunwald Date: Fri, 6 May 2005 20:15:34 +0000 Subject: [PATCH] Worked on code completion. git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@127 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61 --- .../Dom/Implementations/DefaultReturnType.cs | 26 ++++++++++++- .../Dom/Implementations/SpecificReturnType.cs | 26 +++++++++++++ .../NRefactoryASTConvertVisitor.cs | 39 +++++++++++++++++-- .../Src/Dom/NRefactoryResolver/TypeVisitor.cs | 3 +- .../ReflectionLayer/ReflectionReturnType.cs | 14 ++++++- 5 files changed, 101 insertions(+), 7 deletions(-) diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs index 4871b809cc..052812a4b0 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs @@ -26,7 +26,25 @@ namespace ICSharpCode.SharpDevelop.Dom { List l = new List(); foreach (IClass bc in c.ClassInheritanceTree) { - l.AddRange(bc.Methods); + if (bc.ClassType != c.ClassType) + continue; // ignore explicit interface implementations + + // do not add methods that were overridden + foreach (IMethod m in bc.Methods) { + bool ok = true; + foreach (IMethod oldMethod in l) { + if (string.Equals(oldMethod.Name, m.Name, StringComparison.InvariantCultureIgnoreCase)) { + if (m.IsStatic == oldMethod.IsStatic) { + if (DiffUtility.Compare(oldMethod.Parameters, m.Parameters) == 0) { + ok = false; + break; + } + } + } + } + if (ok) + l.Add(m); + } } return l; } @@ -35,6 +53,8 @@ namespace ICSharpCode.SharpDevelop.Dom { List l = new List(); foreach (IClass bc in c.ClassInheritanceTree) { + if (bc.ClassType != c.ClassType) + continue; // ignore explicit interface implementations l.AddRange(bc.Properties); } return l; @@ -44,6 +64,8 @@ namespace ICSharpCode.SharpDevelop.Dom { List l = new List(); foreach (IClass bc in c.ClassInheritanceTree) { + if (bc.ClassType != c.ClassType) + continue; // ignore explicit interface implementations l.AddRange(bc.Fields); } return l; @@ -53,6 +75,8 @@ namespace ICSharpCode.SharpDevelop.Dom { List l = new List(); foreach (IClass bc in c.ClassInheritanceTree) { + if (bc.ClassType != c.ClassType) + continue; // ignore explicit interface implementations l.AddRange(bc.Events); } return l; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs index 3113d02b36..b7b5023a85 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs @@ -7,6 +7,7 @@ using System; using System.Collections.Generic; +using System.Text; using ICSharpCode.Core; namespace ICSharpCode.SharpDevelop.Dom @@ -70,6 +71,11 @@ namespace ICSharpCode.SharpDevelop.Dom return rt.TypeParameter.Method == null; } else if (t is ArrayReturnType) { return CheckReturnType(((ArrayReturnType)t).ElementType); + } else if (t is SpecificReturnType) { + foreach (IReturnType para in ((SpecificReturnType)t).TypeParameters) { + if (CheckReturnType(para)) return true; + } + return false; } else { return false; } @@ -83,6 +89,19 @@ namespace ICSharpCode.SharpDevelop.Dom return false; } + public override string DotNetName { + get { + StringBuilder b = new StringBuilder(baseType.DotNetName); + b.Append('{'); + for (int i = 0; i < typeParameters.Count; ++i) { + if (i > 0) b.Append(','); + b.Append(typeParameters[i].DotNetName); + } + b.Append('}'); + return b.ToString(); + } + } + IReturnType TranslateType(IReturnType input) { if (input is GenericReturnType) { @@ -97,6 +116,13 @@ namespace ICSharpCode.SharpDevelop.Dom IReturnType t = TranslateType(e); if (e != t) return new ArrayReturnType(t, input.ArrayDimensions); + } else if (input is SpecificReturnType) { + SpecificReturnType r = (SpecificReturnType)input; + List para = new List(r.TypeParameters.Count); + for (int i = 0; i < r.TypeParameters.Count; ++i) { + para.Add(TranslateType(r.TypeParameters[i])); + } + return new SpecificReturnType(r.baseType, para); } return input; } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs index e16e209b88..c4264bf922 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs @@ -42,8 +42,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver ModifierEnum ConvertModifier(AST.Modifier m, ModifierEnum defaultModifier) { - // TODO: Is this possible? I think we have to pay caution to defaultModifier - return (ModifierEnum)m; + ModifierEnum r = (ModifierEnum)m; + if (r == ModifierEnum.None) + return defaultModifier; + else + return r; } public override object Visit(AST.CompilationUnit compilationUnit, object data) @@ -190,6 +193,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver c.BaseTypes.Add(type); } } + int index = 0; + foreach (AST.TemplateDefinition template in typeDeclaration.Templates) { + c.TypeParameters.Add(new DefaultTypeParameter(c, template.Name, index++)); + } currentClass.Push(c); object ret = typeDeclaration.AcceptChildren(this, data); currentClass.Pop(); @@ -214,8 +221,29 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } cu.Classes.Add(c); } - DefaultMethod invokeMethod = new DefaultMethod("Invoke", CreateReturnType(delegateDeclaration.ReturnType), ConvertModifier(delegateDeclaration.Modifier), null, null, c); + currentClass.Push(c); // necessary for CreateReturnType + DefaultMethod invokeMethod = new DefaultMethod("Invoke", CreateReturnType(delegateDeclaration.ReturnType), ModifierEnum.Public, null, null, c); + if (delegateDeclaration.Parameters != null) { + foreach (AST.ParameterDeclarationExpression par in delegateDeclaration.Parameters) { + IReturnType parType = CreateReturnType(par.TypeReference); + invokeMethod.Parameters.Add(new DefaultParameter(par.ParameterName, parType, null)); + } + } c.Methods.Add(invokeMethod); + invokeMethod = new DefaultMethod("BeginInvoke", CreateReturnType(typeof(IAsyncResult)), ModifierEnum.Public, null, null, c); + if (delegateDeclaration.Parameters != null) { + foreach (AST.ParameterDeclarationExpression par in delegateDeclaration.Parameters) { + IReturnType parType = CreateReturnType(par.TypeReference); + invokeMethod.Parameters.Add(new DefaultParameter(par.ParameterName, parType, null)); + } + } + invokeMethod.Parameters.Add(new DefaultParameter("callback", CreateReturnType(typeof(AsyncCallback)), null)); + invokeMethod.Parameters.Add(new DefaultParameter("object", CreateReturnType(typeof(object)), null)); + c.Methods.Add(invokeMethod); + invokeMethod = new DefaultMethod("EndInvoke", CreateReturnType(delegateDeclaration.ReturnType), ModifierEnum.Public, null, null, c); + invokeMethod.Parameters.Add(new DefaultParameter("result", CreateReturnType(typeof(IAsyncResult)), null)); + c.Methods.Add(invokeMethod); + currentClass.Pop(); return c; } @@ -358,5 +386,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (c == null) return null; return TypeVisitor.CreateReturnType(reference, c, c.Region.BeginLine + 1, 1); } + + IReturnType CreateReturnType(Type type) + { + return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type); + } } } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs index 0b1d78aae7..b9f6f4cef1 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs @@ -391,8 +391,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver IReturnType CreateReturnType(Type type) { - return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), - type); + return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type); } } } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs index a96dd8f367..78bbaf3856 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs @@ -5,7 +5,7 @@ // // using System; -using System.Collections; +using System.Collections.Generic; using ICSharpCode.Core; namespace ICSharpCode.SharpDevelop.Dom @@ -17,6 +17,11 @@ namespace ICSharpCode.SharpDevelop.Dom string name = type.FullName; if (name == null) return null; + if (name.Length > 2) { + if (name[name.Length - 2] == '`') { + name = name.Substring(0, name.Length - 2); + } + } if (type.IsArray) { return MakeArray(type, Create(content, type.GetElementType())); } else { @@ -28,6 +33,13 @@ namespace ICSharpCode.SharpDevelop.Dom { if (type.IsArray) { return MakeArray(type, Create(member, type.GetElementType())); + } else if (type.IsGenericType && !type.IsGenericTypeDefinition) { + Type[] args = type.GetGenericArguments(); + List para = new List(args.Length); + for (int i = 0; i < args.Length; ++i) { + para.Add(Create(member, args[i])); + } + return new SpecificReturnType(Create(member, type.GetGenericTypeDefinition()), para); } else if (type.IsGenericParameter) { IClass c = member.DeclaringType; if (type.GenericParameterPosition < c.TypeParameters.Count) {