diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/BooAmbience.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/BooAmbience.cs index f23191f5c2..2064a64ae6 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/BooAmbience.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/BooAmbience.cs @@ -492,20 +492,22 @@ namespace Grunwald.BooBinding void UnpackNestedType(StringBuilder builder, IReturnType returnType) { - if (returnType.ArrayDimensions > 0) { + if (returnType.IsArrayReturnType) { + ArrayReturnType art = returnType.CastToArrayReturnType(); builder.Append('('); - UnpackNestedType(builder, returnType.ArrayElementType); - if (returnType.ArrayDimensions > 1) { + UnpackNestedType(builder, art.ArrayElementType); + if (art.ArrayDimensions > 1) { builder.Append(','); - builder.Append(returnType.ArrayDimensions); + builder.Append(art.ArrayDimensions); } builder.Append(')'); - } else if (returnType.TypeArguments != null) { - UnpackNestedType(builder, returnType.UnboundType); + } else if (returnType.IsConstructedReturnType) { + ConstructedReturnType crt = returnType.CastToConstructedReturnType(); + UnpackNestedType(builder, crt.UnboundType); builder.Append("[of "); - for (int i = 0; i < returnType.TypeArguments.Count; ++i) { + for (int i = 0; i < crt.TypeArguments.Count; ++i) { if (i > 0) builder.Append(", "); - builder.Append(Convert(returnType.TypeArguments[i])); + builder.Append(Convert(crt.TypeArguments[i])); } builder.Append(']'); } else { diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs index 5bc30aa0eb..7ffd533801 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs @@ -207,7 +207,7 @@ namespace Grunwald.BooBinding.CodeCompletion if (expr == null) return null; if (expr is AST.IntegerLiteralExpression) - return new IntegerLiteralResolveResult(callingClass, callingMember); + return new IntegerLiteralResolveResult(callingClass, callingMember, pc.SystemTypes.Int32); if (expressionResult.Context == ExpressionFinder.BooAttributeContext.Instance) { AST.MethodInvocationExpression mie = expr as AST.MethodInvocationExpression; diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ConvertVisitor.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ConvertVisitor.cs index 8850fa66cf..a6de8c56af 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ConvertVisitor.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ConvertVisitor.cs @@ -221,7 +221,7 @@ namespace Grunwald.BooBinding.CodeCompletion if (project != null && project.Ducky) return new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType; else - return ReflectionReturnType.Object; + return projectContent.SystemTypes.Object; } public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass, @@ -234,7 +234,8 @@ namespace Grunwald.BooBinding.CodeCompletion } if (reference is AST.ArrayTypeReference) { AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference; - return new ArrayReturnType(CreateReturnType(arr.ElementType, callingClass, callingMember, + return new ArrayReturnType(projectContent, + CreateReturnType(arr.ElementType, callingClass, callingMember, caretLine, caretColumn, projectContent), (arr.Rank != null) ? (int)arr.Rank.Value : 1); } else if (reference is AST.SimpleTypeReference) { @@ -275,10 +276,6 @@ namespace Grunwald.BooBinding.CodeCompletion { return CreateReturnType(reference, null); } - IReturnType CreateReturnType(Type type) - { - return ReflectionReturnType.CreatePrimitive(type); - } IReturnType CreateReturnType(AST.Field field) { if (field.Type == null) { @@ -309,7 +306,7 @@ namespace Grunwald.BooBinding.CodeCompletion DomRegion region = GetRegion(node); DefaultClass c = new DefaultClass(_cu, ClassType.Delegate, GetModifier(node), region, OuterClass); ConvertAttributes(node, c); - c.BaseTypes.Add(ReflectionReturnType.CreatePrimitive(typeof(Delegate))); + c.BaseTypes.Add(c.ProjectContent.SystemTypes.Delegate); c.FullyQualifiedName = node.FullName; if (_currentClass.Count > 0) { OuterClass.InnerClasses.Add(c); @@ -322,16 +319,16 @@ namespace Grunwald.BooBinding.CodeCompletion DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); ConvertParameters(node.Parameters, invokeMethod); c.Methods.Add(invokeMethod); - invokeMethod = new DefaultMethod("BeginInvoke", CreateReturnType(typeof(IAsyncResult)), ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); + invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); ConvertParameters(node.Parameters, invokeMethod); if (invokeMethod.Parameters == DefaultParameter.EmptyParameterList) { invokeMethod.Parameters = new List(); } - invokeMethod.Parameters.Add(new DefaultParameter("callback", CreateReturnType(typeof(AsyncCallback)), DomRegion.Empty)); - invokeMethod.Parameters.Add(new DefaultParameter("object", ReflectionReturnType.Object, DomRegion.Empty)); + invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty)); + invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty)); c.Methods.Add(invokeMethod); invokeMethod = new DefaultMethod("EndInvoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); - invokeMethod.Parameters.Add(new DefaultParameter("result", CreateReturnType(typeof(IAsyncResult)), DomRegion.Empty)); + invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty)); c.Methods.Add(invokeMethod); _currentClass.Pop(); } diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ElementReturnType.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ElementReturnType.cs index 2556a4d9b8..aaecd45737 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ElementReturnType.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ElementReturnType.cs @@ -18,37 +18,41 @@ namespace Grunwald.BooBinding.CodeCompletion public class ElementReturnType : ProxyReturnType { IReturnType listType; + IProjectContent pc; - public ElementReturnType(IReturnType listType) + public ElementReturnType(IProjectContent pc, IReturnType listType) { + if (pc == null) + throw new ArgumentNullException("pc"); // listType is probably an InferredReturnType this.listType = listType; + this.pc = pc; } public override IReturnType BaseType { get { // get element type from listType - if (listType.ArrayDimensions > 0) - return listType.ArrayElementType; + if (listType.IsArrayReturnType) + return listType.CastToArrayReturnType().ArrayElementType; IClass c = listType.GetUnderlyingClass(); if (c == null) return null; - IClass genumerable = ProjectContentRegistry.Mscorlib.GetClass("System.Collections.Generic.IEnumerable", 1); + IClass genumerable = pc.GetClass("System.Collections.Generic.IEnumerable", 1); if (c.IsTypeInInheritanceTree(genumerable)) { return MemberLookupHelper.GetTypeParameterPassedToBaseClass(listType, genumerable, 0); } - IClass enumerable = ProjectContentRegistry.Mscorlib.GetClass("System.Collections.IEnumerable", 0); + IClass enumerable = pc.GetClass("System.Collections.IEnumerable", 0); if (c.IsTypeInInheritanceTree(enumerable)) { // We can't use the EnumeratorItemType attribute because SharpDevelop // does not store attribute argument values in the cache. // HACK: Hacked in support for range(), take out when RangeEnumerator implements IEnumerable if (c.FullyQualifiedName == "Boo.Lang.Builtins.RangeEnumerator") { - return ReflectionReturnType.Int; + return pc.SystemTypes.Int32; } - return ReflectionReturnType.Object; + return pc.SystemTypes.Object; } return null; } diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/InferredReturnType.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/InferredReturnType.cs index a7a70a2298..9590dc1198 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/InferredReturnType.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/InferredReturnType.cs @@ -51,10 +51,10 @@ namespace Grunwald.BooBinding.CodeCompletion if (useLastStatementIfNoReturnStatement && v.lastExpressionStatement != null) { cachedType = new BooResolver().GetTypeOfExpression(v.lastExpressionStatement.Expression, context); } else { - cachedType = ReflectionReturnType.Void; + cachedType = VoidReturnType.Instance; } } else if (v.result is NullReturnType) { - cachedType = ReflectionReturnType.Object; + cachedType = ConvertVisitor.GetDefaultReturnType(ParserService.CurrentProjectContent); } else { cachedType = v.result; } @@ -83,7 +83,7 @@ namespace Grunwald.BooBinding.CodeCompletion { noReturnStatement = false; if (node.Expression == null) { - result = ReflectionReturnType.Void; + result = VoidReturnType.Instance; } else { result = new BooResolver().GetTypeOfExpression(node.Expression, context); } diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs index 673c40ebe0..4dba722e33 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs @@ -55,8 +55,7 @@ namespace Grunwald.BooBinding.CodeCompletion void MakeLiteralResult(string fullTypeName) { - resolveResult = new ResolveResult(callingClass, resolver.CallingMember, - new GetClassReturnType(projectContent, fullTypeName, 0)); + MakeResult(new GetClassReturnType(projectContent, fullTypeName, 0)); } void MakeResult(IMember member) @@ -427,7 +426,7 @@ namespace Grunwald.BooBinding.CodeCompletion resolveResult.ResolvedType = invoke.ReturnType; } } else if (c.FullyQualifiedName == "System.Type") { - resolveResult.ResolvedType = ReflectionReturnType.Object; + resolveResult.ResolvedType = projectContent.SystemTypes.Object; } else { ClearResult(); } @@ -446,7 +445,7 @@ namespace Grunwald.BooBinding.CodeCompletion arguments[0].Accept(this); TypeResolveResult trr = resolveResult as TypeResolveResult; if (trr != null) { - MakeResult(new ArrayReturnType(trr.ResolvedType, 1)); + MakeResult(new ArrayReturnType(projectContent, trr.ResolvedType, 1)); } } else { ResolveMethodInType(new GetClassReturnType(projectContent, "Boo.Lang.Builtins", 0), @@ -562,7 +561,7 @@ namespace Grunwald.BooBinding.CodeCompletion case BinaryOperatorType.ReferenceEquality: case BinaryOperatorType.ReferenceInequality: case BinaryOperatorType.TypeTest: - MakeResult(ReflectionReturnType.Bool); + MakeResult(projectContent.SystemTypes.Boolean); break; default: if (node.Left == null) { @@ -580,7 +579,7 @@ namespace Grunwald.BooBinding.CodeCompletion IReturnType left = (resolveResult != null) ? resolveResult.ResolvedType : null; node.Right.Accept(this); IReturnType right = (resolveResult != null) ? resolveResult.ResolvedType : null; - MakeResult(MemberLookupHelper.GetCommonType(left, right)); + MakeResult(MemberLookupHelper.GetCommonType(projectContent, left, right)); break; } } @@ -632,11 +631,11 @@ namespace Grunwald.BooBinding.CodeCompletion if (elementType == null) elementType = thisType; else if (thisType != null) - elementType = MemberLookupHelper.GetCommonType(elementType, thisType); + elementType = MemberLookupHelper.GetCommonType(projectContent, elementType, thisType); } if (elementType == null) - elementType = ReflectionReturnType.Object; - MakeResult(new ArrayReturnType(elementType, 1)); + elementType = ConvertVisitor.GetDefaultReturnType(projectContent); + MakeResult(new ArrayReturnType(projectContent, elementType, 1)); } public override void OnTryCastExpression(TryCastExpression node) @@ -651,7 +650,7 @@ namespace Grunwald.BooBinding.CodeCompletion public override void OnBoolLiteralExpression(BoolLiteralExpression node) { - MakeResult(ReflectionReturnType.Bool); + MakeResult(projectContent.SystemTypes.Boolean); } public override void OnDoubleLiteralExpression(DoubleLiteralExpression node) @@ -677,7 +676,7 @@ namespace Grunwald.BooBinding.CodeCompletion if (node.IsLong) MakeLiteralResult("System.Int64"); else - MakeResult(ReflectionReturnType.Int); + MakeResult(projectContent.SystemTypes.Int32); } public override void OnNullLiteralExpression(NullLiteralExpression node) @@ -708,7 +707,7 @@ namespace Grunwald.BooBinding.CodeCompletion public override void OnStringLiteralExpression(StringLiteralExpression node) { - MakeResult(ReflectionReturnType.String); + MakeResult(projectContent.SystemTypes.String); } public override void OnTimeSpanLiteralExpression(TimeSpanLiteralExpression node) @@ -718,7 +717,7 @@ namespace Grunwald.BooBinding.CodeCompletion public override void OnTypeofExpression(TypeofExpression node) { - MakeLiteralResult("System.Type"); + MakeResult(projectContent.SystemTypes.Type); } IReturnType ConvertType(TypeReference typeRef) diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/VariableLookupVisitor.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/VariableLookupVisitor.cs index b1090443fd..94bcac2b69 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/VariableLookupVisitor.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/VariableLookupVisitor.cs @@ -182,7 +182,7 @@ namespace Grunwald.BooBinding.CodeCompletion expr.Annotate("DomReturnType", returnType); } if (useElementType) - returnType = new ElementReturnType(returnType); + returnType = new ElementReturnType(resolver.ProjectContent, returnType); result = new DefaultField.LocalVariableField(returnType, name, new DomRegion(lexicalInfo.Line, lexicalInfo.Column), resolver.CallingClass); @@ -218,7 +218,8 @@ namespace Grunwald.BooBinding.CodeCompletion if (results.ContainsKey(name)) return; if (elementReturnType) - results.Add(name, new ElementReturnType(new InferredReturnType(expr, resolver.CallingClass))); + results.Add(name, new ElementReturnType(resolver.ProjectContent, + new InferredReturnType(expr, resolver.CallingClass))); else results.Add(name, new InferredReturnType(expr, resolver.CallingClass)); } diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/BooDesignerGenerator.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/BooDesignerGenerator.cs index 126b1f1bac..b93218694e 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/BooDesignerGenerator.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/BooDesignerGenerator.cs @@ -52,10 +52,14 @@ namespace Grunwald.BooBinding.Designer if (m.Name == cmie.Method.MethodName && m.Parameters.Count == 1 && m.Parameters[0].IsParams - && m.Parameters[0].ReturnType.ArrayDimensions == 1 - && m.Parameters[0].ReturnType.ArrayElementType.FullyQualifiedName == cace.CreateType.BaseType) + && m.Parameters[0].ReturnType.IsArrayReturnType) { - cace.UserData["Explode"] = true; + ArrayReturnType paramArt = m.Parameters[0].ReturnType.CastToArrayReturnType(); + if (paramArt.ArrayDimensions == 1 + && paramArt.FullyQualifiedName == cace.CreateType.BaseType) + { + cace.UserData["Explode"] = true; + } } } } diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/CodeDomVisitor.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/CodeDomVisitor.cs index d70192e2a1..264b409f4f 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/CodeDomVisitor.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/Designer/CodeDomVisitor.cs @@ -38,6 +38,8 @@ namespace Grunwald.BooBinding.Designer public CodeDomVisitor(IProjectContent pc) { + if (pc == null) + throw new ArgumentNullException("pc"); this.pc = pc; } @@ -509,7 +511,7 @@ namespace Grunwald.BooBinding.Designer for (int i = 0; i < count; i++) { CodeArrayCreateExpression cace = cmie.Parameters[i] as CodeArrayCreateExpression; if (cace != null && (bool)cace.UserData["unknownType"] - && m.Parameters[i].ReturnType.ArrayDimensions > 0) + && m.Parameters[i].ReturnType.IsArrayReturnType) { cace.CreateType = new CodeTypeReference(m.Parameters[i].ReturnType.FullyQualifiedName); } @@ -555,7 +557,7 @@ namespace Grunwald.BooBinding.Designer BooResolver resolver = new BooResolver(); IReturnType createType = resolver.GetTypeOfExpression(node, null); if (createType == null) - createType = ReflectionReturnType.Object; + createType = pc.SystemTypes.Object; CodeExpression[] initializers = new CodeExpression[node.Items.Count]; for (int i = 0; i < initializers.Length; i++) { _expression = null; diff --git a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs index 8de64ec886..7c9464c792 100644 --- a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs +++ b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs @@ -7,6 +7,7 @@ using System; using System.Collections; +using System.Collections.Generic; using System.Text; using ICSharpCode.SharpDevelop.Dom; @@ -497,19 +498,21 @@ namespace ICSharpCode.Core void UnpackNestedType(StringBuilder builder, IReturnType returnType) { - if (returnType.ArrayDimensions > 0) { + if (returnType.IsArrayReturnType) { builder.Append('['); - for (int i = 1; i < returnType.ArrayDimensions; ++i) { + int dimensions = returnType.CastToArrayReturnType().ArrayDimensions; + for (int i = 1; i < dimensions; ++i) { builder.Append(','); } builder.Append(']'); - UnpackNestedType(builder, returnType.ArrayElementType); - } else if (returnType.TypeArguments != null) { - UnpackNestedType(builder, returnType.UnboundType); + UnpackNestedType(builder, returnType.CastToArrayReturnType().ArrayElementType); + } else if (returnType.IsConstructedReturnType) { + UnpackNestedType(builder, returnType.CastToConstructedReturnType().UnboundType); builder.Append('<'); - for (int i = 0; i < returnType.TypeArguments.Count; ++i) { + IList ta = returnType.CastToConstructedReturnType().TypeArguments; + for (int i = 0; i < ta.Count; ++i) { if (i > 0) builder.Append(", "); - builder.Append(Convert(returnType.TypeArguments[i])); + builder.Append(Convert(ta[i])); } builder.Append('>'); } diff --git a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpCompletionBinding.cs b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpCompletionBinding.cs index 5df6f6419b..b218cc68db 100644 --- a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpCompletionBinding.cs +++ b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpCompletionBinding.cs @@ -35,10 +35,10 @@ namespace CSharpBinding context = ExpressionContext.Default; break; case "using": - context = ExpressionContext.TypeDerivingFrom(ReflectionReturnType.Disposable.GetUnderlyingClass(), false); + context = ExpressionContext.TypeDerivingFrom(ParserService.CurrentProjectContent.GetClass("System.IDisposable"), false); break; case "catch": - context = ExpressionContext.TypeDerivingFrom(ReflectionReturnType.Exception.GetUnderlyingClass(), false); + context = ExpressionContext.TypeDerivingFrom(ParserService.CurrentProjectContent.GetClass("System.Exception"), false); break; case "foreach": case "typeof": @@ -108,7 +108,7 @@ namespace CSharpBinding ResolveResult resolveResult = ParserService.Resolve(result, editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1, editor.FileName, documentText); if (resolveResult != null && resolveResult.ResolvedType != null) { IClass underlyingClass = resolveResult.ResolvedType.GetUnderlyingClass(); - if (underlyingClass != null && underlyingClass.IsTypeInInheritanceTree(ProjectContentRegistry.Mscorlib.GetClass("System.MulticastDelegate"))) { + if (underlyingClass != null && underlyingClass.IsTypeInInheritanceTree(ParserService.CurrentProjectContent.GetClass("System.MulticastDelegate"))) { EventHandlerCompletitionDataProvider eventHandlerProvider = new EventHandlerCompletitionDataProvider(result.Expression, resolveResult); eventHandlerProvider.InsertSpace = true; editor.ShowCompletionWindow(eventHandlerProvider, ch); diff --git a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/ExpressionFinder.cs b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/ExpressionFinder.cs index e6284382fb..fb11d056a8 100644 --- a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/ExpressionFinder.cs +++ b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/ExpressionFinder.cs @@ -97,7 +97,7 @@ namespace CSharpBinding.Parser UnGet(); ReadNextToken(); if (curTokenType == Ident && lastIdentifier == "throw") { - return ExpressionContext.TypeDerivingFrom(ProjectContentRegistry.Mscorlib.GetClass("System.Exception"), true); + return ExpressionContext.TypeDerivingFrom(ParserService.CurrentProjectContent.GetClass("System.Exception"), true); } } return ExpressionContext.ObjectCreation; diff --git a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs index b39393bcde..20cff85478 100644 --- a/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs +++ b/src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs @@ -7,6 +7,7 @@ using System; using System.Collections; +using System.Collections.Generic; using System.Text; using ICSharpCode.SharpDevelop.Dom; @@ -491,19 +492,21 @@ namespace VBNetBinding void UnpackNestedType(StringBuilder builder, IReturnType returnType) { - if (returnType.ArrayDimensions > 0) { + if (returnType.IsArrayReturnType) { builder.Append('('); - for (int i = 1; i < returnType.ArrayDimensions; ++i) { + int dimensions = returnType.CastToArrayReturnType().ArrayDimensions; + for (int i = 1; i < dimensions; ++i) { builder.Append(','); } builder.Append(')'); - UnpackNestedType(builder, returnType.ArrayElementType); - } else if (returnType.TypeArguments != null) { - UnpackNestedType(builder, returnType.UnboundType); + UnpackNestedType(builder, returnType.CastToArrayReturnType().ArrayElementType); + } else if (returnType.IsConstructedReturnType) { + UnpackNestedType(builder, returnType.CastToConstructedReturnType().UnboundType); builder.Append("(Of "); - for (int i = 0; i < returnType.TypeArguments.Count; ++i) { + IList ta = returnType.CastToConstructedReturnType().TypeArguments; + for (int i = 0; i < ta.Count; ++i) { if (i > 0) builder.Append(", "); - builder.Append(Convert(returnType.TypeArguments[i])); + builder.Append(Convert(ta[i])); } builder.Append(')'); } diff --git a/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj b/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj index 8b3a8ce0ce..31e3558094 100644 --- a/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj +++ b/src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj @@ -771,6 +771,7 @@ + diff --git a/src/Main/Base/Project/Src/Dom/IReturnType.cs b/src/Main/Base/Project/Src/Dom/IReturnType.cs index 2a402869ca..8afcb8bae3 100644 --- a/src/Main/Base/Project/Src/Dom/IReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/IReturnType.cs @@ -62,22 +62,6 @@ namespace ICSharpCode.SharpDevelop.Dom get; } - /// - /// Gets the array ranks of the return type. - /// When the return type is not an array, this property returns 0. - /// - int ArrayDimensions { - get; - } - - /// - /// Gets the element type of the array. - /// When the return type is not an array, a NotSupportedException is thrown. - /// - IReturnType ArrayElementType { - get; - } - /// /// Gets the count of type parameters the target class should have. /// @@ -85,33 +69,6 @@ namespace ICSharpCode.SharpDevelop.Dom get; } - /// - /// Gets if the return type is a default type, i.e. no array, generic etc. - /// - /// - /// True for SearchClassReturnType, GetClassReturnType and DefaultReturnType.
- /// False for ArrayReturnType, SpecificReturnType etc. - /// - bool IsDefaultReturnType { - get; - } - - /// - /// Gets the type arguments used if this is a ConstructedReturnType. - /// Otherwise, null is returned. - /// - IList TypeArguments { - get; - } - - /// - /// Gets the unbound type if this is a ConstructedReturnType. - /// Otherwise, a NotSupportedException is thrown. - /// - IReturnType UnboundType { - get; - } - /// /// Gets the underlying class of this return type. This method will return null for /// generic return types and types that cannot be resolved. @@ -137,5 +94,24 @@ namespace ICSharpCode.SharpDevelop.Dom /// Gets all events that can be called on this return type. /// List GetEvents(); + + + /// + /// Gets if the return type is a default type, i.e. no array, generic etc. + /// + /// + /// True for SearchClassReturnType, GetClassReturnType and DefaultReturnType.
+ /// False for ArrayReturnType, SpecificReturnType etc. + /// + bool IsDefaultReturnType { get; } + + bool IsArrayReturnType { get; } + ArrayReturnType CastToArrayReturnType(); + + bool IsGenericReturnType { get; } + GenericReturnType CastToGenericReturnType(); + + bool IsConstructedReturnType { get; } + ConstructedReturnType CastToConstructedReturnType(); } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs index 8efbe62f2b..18538879f5 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs @@ -80,34 +80,40 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public int ArrayDimensions { - get { - return 0; - } - } - public virtual bool IsDefaultReturnType { get { return true; } } - public IReturnType ArrayElementType { + public virtual bool IsArrayReturnType { get { - throw new NotSupportedException(); + return false; } } + public virtual ArrayReturnType CastToArrayReturnType() + { + throw new InvalidCastException("Cannot cast " + ToString() + " to expected type."); + } - public IReturnType UnboundType { + public virtual bool IsGenericReturnType { get { - throw new NotSupportedException(); + return false; } } + public virtual GenericReturnType CastToGenericReturnType() + { + throw new InvalidCastException("Cannot cast " + ToString() + " to expected type."); + } - public IList TypeArguments { + public virtual bool IsConstructedReturnType { get { - return null; + return false; } } + public virtual ConstructedReturnType CastToConstructedReturnType() + { + throw new InvalidCastException("Cannot cast " + ToString() + " to expected type."); + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/AnonymousMethodReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/AnonymousMethodReturnType.cs index 7e33697378..683aaaff90 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/AnonymousMethodReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/AnonymousMethodReturnType.cs @@ -59,8 +59,8 @@ namespace ICSharpCode.SharpDevelop.Dom { if (cachedClass != null) return cachedClass; DefaultClass c = new DefaultClass(cu, ClassType.Delegate, ModifierEnum.None, DomRegion.Empty, null); - c.BaseTypes.Add(ReflectionReturnType.CreatePrimitive(typeof(Delegate))); - AddDefaultDelegateMethod(c, returnType ?? ReflectionReturnType.Object, parameters); + c.BaseTypes.Add(cu.ProjectContent.SystemTypes.Delegate); + AddDefaultDelegateMethod(c, returnType ?? cu.ProjectContent.SystemTypes.Object, parameters); cachedClass = c; return c; } @@ -72,23 +72,18 @@ namespace ICSharpCode.SharpDevelop.Dom invokeMethod.Parameters.Add(par); } c.Methods.Add(invokeMethod); - invokeMethod = new DefaultMethod("BeginInvoke", CreateReturnType(typeof(IAsyncResult)), ModifierEnum.Public, c.Region, DomRegion.Empty, c); + invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, ModifierEnum.Public, c.Region, DomRegion.Empty, c); foreach (IParameter par in parameters) { invokeMethod.Parameters.Add(par); } - invokeMethod.Parameters.Add(new DefaultParameter("callback", CreateReturnType(typeof(AsyncCallback)), DomRegion.Empty)); - invokeMethod.Parameters.Add(new DefaultParameter("object", ReflectionReturnType.Object, DomRegion.Empty)); + invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty)); + invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty)); c.Methods.Add(invokeMethod); invokeMethod = new DefaultMethod("EndInvoke", returnType, ModifierEnum.Public, c.Region, DomRegion.Empty, c); - invokeMethod.Parameters.Add(new DefaultParameter("result", CreateReturnType(typeof(IAsyncResult)), DomRegion.Empty)); + invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty)); c.Methods.Add(invokeMethod); } - static IReturnType CreateReturnType(Type type) - { - return ReflectionReturnType.Create(ProjectContentRegistry.Mscorlib, null, type, false); - } - public override IReturnType BaseType { get { return GetUnderlyingClass().DefaultReturnType; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs index 54f9db4a8e..c54af90fdd 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs @@ -22,13 +22,23 @@ namespace ICSharpCode.SharpDevelop.Dom { IReturnType elementType; int dimensions; + IProjectContent pc; - public ArrayReturnType(IReturnType elementType, int dimensions) + internal IProjectContent ProjectContent { + get { + return pc; + } + } + + public ArrayReturnType(IProjectContent pc, IReturnType elementType, int dimensions) { + if (pc == null) + throw new ArgumentNullException("pc"); if (dimensions <= 0) throw new ArgumentOutOfRangeException("dimensions", dimensions, "dimensions must be positive"); if (elementType == null) throw new ArgumentNullException("elementType"); + this.pc = pc; this.elementType = elementType; this.dimensions = dimensions; } @@ -36,9 +46,10 @@ namespace ICSharpCode.SharpDevelop.Dom public override bool Equals(object o) { IReturnType rt = o as IReturnType; - if (rt == null) return false; - if (rt.ArrayDimensions != dimensions) return false; - return elementType.Equals(rt.ArrayElementType); + if (rt == null || !rt.IsArrayReturnType) return false; + ArrayReturnType art = rt.CastToArrayReturnType(); + if (art.ArrayDimensions != dimensions) return false; + return elementType.Equals(art.ArrayElementType); } public override int GetHashCode() @@ -48,12 +59,18 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public override IReturnType ArrayElementType { + public IReturnType ArrayElementType { get { return elementType; } } + public int ArrayDimensions { + get { + return dimensions; + } + } + public override string FullyQualifiedName { get { return elementType.FullyQualifiedName; @@ -74,7 +91,7 @@ namespace ICSharpCode.SharpDevelop.Dom public override IReturnType BaseType { get { - return ReflectionReturnType.Array; + return pc.SystemTypes.Array; } } @@ -83,8 +100,8 @@ namespace ICSharpCode.SharpDevelop.Dom /// public class ArrayIndexer : DefaultProperty { - public ArrayIndexer(IReturnType elementType) - : base("Indexer", elementType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, ReflectionReturnType.Array.GetUnderlyingClass()) + public ArrayIndexer(IReturnType elementType, IClass systemArray) + : base("Indexer", elementType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, systemArray) { IsIndexer = true; } @@ -93,26 +110,15 @@ namespace ICSharpCode.SharpDevelop.Dom public override List GetProperties() { List l = base.GetProperties(); - ArrayIndexer property = new ArrayIndexer(elementType); + ArrayIndexer property = new ArrayIndexer(elementType, this.BaseType.GetUnderlyingClass()); + IReturnType int32 = pc.SystemTypes.Int32; for (int i = 0; i < dimensions; ++i) { - property.Parameters.Add(new DefaultParameter("index", ReflectionReturnType.Int, DomRegion.Empty)); + property.Parameters.Add(new DefaultParameter("index", int32, DomRegion.Empty)); } l.Add(property); return l; } - public override int ArrayDimensions { - get { - return dimensions; - } - } - - public override bool IsDefaultReturnType { - get { - return false; - } - } - /// /// Appends the array characters ([,,,]) to the string . /// @@ -131,5 +137,34 @@ namespace ICSharpCode.SharpDevelop.Dom { return String.Format("[ArrayReturnType: {0}, dimensions={1}]", elementType, AppendArrayString("")); } + + public override bool IsDefaultReturnType { + get { + return false; + } + } + + public override bool IsArrayReturnType { + get { + return true; + } + } + + public override ArrayReturnType CastToArrayReturnType() + { + return this; + } + + public override bool IsConstructedReturnType { + get { + return false; + } + } + + public override bool IsGenericReturnType { + get { + return false; + } + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/ConstructedReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/ConstructedReturnType.cs index 3835007a20..ae6f8e489d 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/ConstructedReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/ConstructedReturnType.cs @@ -27,7 +27,7 @@ namespace ICSharpCode.SharpDevelop.Dom IList typeArguments; IReturnType baseType; - public override IList TypeArguments { + public IList TypeArguments { get { return typeArguments; } @@ -67,7 +67,7 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public override IReturnType UnboundType { + public IReturnType UnboundType { get { return baseType; } @@ -78,10 +78,10 @@ namespace ICSharpCode.SharpDevelop.Dom if (t is GenericReturnType) { GenericReturnType rt = (GenericReturnType)t; return rt.TypeParameter.Method == null; - } else if (t.ArrayDimensions > 0) { - return CheckReturnType(t.ArrayElementType); - } else if (t.TypeArguments != null) { - foreach (IReturnType para in t.TypeArguments) { + } else if (t.IsArrayReturnType) { + return CheckReturnType(t.CastToArrayReturnType().ArrayElementType); + } else if (t.IsConstructedReturnType) { + foreach (IReturnType para in t.CastToConstructedReturnType().TypeArguments) { if (para != null) { if (CheckReturnType(para)) return true; } @@ -126,8 +126,8 @@ namespace ICSharpCode.SharpDevelop.Dom if (typeParameters == null || typeParameters.Count == 0) { return input; // nothing to do when there are no type parameters specified } - if (input is GenericReturnType) { - GenericReturnType rt = (GenericReturnType)input; + if (input.IsGenericReturnType) { + GenericReturnType rt = input.CastToGenericReturnType(); if (convertForMethod ? (rt.TypeParameter.Method != null) : (rt.TypeParameter.Method == null)) { if (rt.TypeParameter.Index < typeParameters.Count) { IReturnType newType = typeParameters[rt.TypeParameter.Index]; @@ -136,17 +136,19 @@ namespace ICSharpCode.SharpDevelop.Dom } } } - } else if (input.ArrayDimensions > 0) { - IReturnType e = input.ArrayElementType; + } else if (input.IsArrayReturnType) { + ArrayReturnType arInput = input.CastToArrayReturnType(); + IReturnType e = arInput.ArrayElementType; IReturnType t = TranslateType(e, typeParameters, convertForMethod); if (e != t && t != null) - return new ArrayReturnType(t, input.ArrayDimensions); - } else if (input.TypeArguments != null) { - List para = new List(input.TypeArguments.Count); - foreach (IReturnType argument in input.TypeArguments) { + return new ArrayReturnType(arInput.ProjectContent, t, arInput.ArrayDimensions); + } else if (input.IsConstructedReturnType) { + ConstructedReturnType cinput = input.CastToConstructedReturnType(); + List para = new List(cinput.TypeArguments.Count); + foreach (IReturnType argument in cinput.TypeArguments) { para.Add(TranslateType(argument, typeParameters, convertForMethod)); } - return new ConstructedReturnType(input.UnboundType, para); + return new ConstructedReturnType(cinput.UnboundType, para); } return input; } @@ -229,5 +231,28 @@ namespace ICSharpCode.SharpDevelop.Dom } return r + ">]"; } + + public override bool IsArrayReturnType { + get { + return false; + } + } + + public override bool IsConstructedReturnType { + get { + return true; + } + } + + public override ConstructedReturnType CastToConstructedReturnType() + { + return this; + } + + public override bool IsGenericReturnType { + get { + return false; + } + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs index 38b9d245fd..1f67fb3670 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultClass.cs @@ -363,15 +363,15 @@ namespace ICSharpCode.SharpDevelop.Dom case ClassType.Class: case ClassType.Interface: if (FullyQualifiedName != "System.Object") { - return ReflectionReturnType.Object; + return this.ProjectContent.SystemTypes.Object; } break; case ClassType.Enum: - return ProjectContentRegistry.Mscorlib.GetClass("System.Enum").DefaultReturnType; + return this.ProjectContent.SystemTypes.Enum; case ClassType.Delegate: - return ReflectionReturnType.Delegate; + return this.ProjectContent.SystemTypes.Delegate; case ClassType.Struct: - return ProjectContentRegistry.Mscorlib.GetClass("System.ValueType").DefaultReturnType; + return this.ProjectContent.SystemTypes.ValueType; } return null; } @@ -386,15 +386,15 @@ namespace ICSharpCode.SharpDevelop.Dom switch (ClassType) { case ClassType.Class: if (FullyQualifiedName != "System.Object") { - return ReflectionReturnType.Object.GetUnderlyingClass(); + return this.ProjectContent.SystemTypes.Object.GetUnderlyingClass(); } break; case ClassType.Enum: - return ProjectContentRegistry.Mscorlib.GetClass("System.Enum"); + return this.ProjectContent.SystemTypes.Enum.GetUnderlyingClass(); case ClassType.Delegate: - return ProjectContentRegistry.Mscorlib.GetClass("System.Delegate"); + return this.ProjectContent.SystemTypes.Delegate.GetUnderlyingClass(); case ClassType.Struct: - return ProjectContentRegistry.Mscorlib.GetClass("System.ValueType"); + return this.ProjectContent.SystemTypes.ValueType.GetUnderlyingClass(); } return null; } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultCompilationUnit.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultCompilationUnit.cs index 30fa0ca3af..e3e7fba7b3 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultCompilationUnit.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultCompilationUnit.cs @@ -16,6 +16,8 @@ namespace ICSharpCode.SharpDevelop.Dom [Serializable] public class DefaultCompilationUnit : ICompilationUnit { + public static readonly ICompilationUnit DummyCompilationUnit = new DefaultCompilationUnit(DefaultProjectContent.DummyProjectContent); + List usings = new List(); List classes = new List(); List attributes = new List(); diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs index ea33b9d93b..bafd5b43f1 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs @@ -53,7 +53,7 @@ namespace ICSharpCode.SharpDevelop.Dom l.AddRange(c.Methods); if (c.ClassType == ClassType.Interface) { if (c.BaseTypes.Count == 0) { - AddMethodsFromBaseType(l, ReflectionReturnType.Object); + AddMethodsFromBaseType(l, c.ProjectContent.SystemTypes.Object); } else { foreach (IReturnType baseType in c.BaseTypes) { AddMethodsFromBaseType(l, baseType); diff --git a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs index ee391382f7..0a6973d8cb 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs @@ -6,7 +6,6 @@ // using System; -using System.Reflection; using System.Collections.Generic; namespace ICSharpCode.SharpDevelop.Dom @@ -91,17 +90,6 @@ namespace ICSharpCode.SharpDevelop.Dom this.index = type.GenericParameterPosition; } - public void AddConstraintsFromType(Type type) - { - foreach (Type constraint in type.GetGenericParameterConstraints()) { - if (method != null) { - constraints.Add(ReflectionReturnType.Create(method, constraint, false)); - } else { - constraints.Add(ReflectionReturnType.Create(targetClass, constraint, false)); - } - } - } - public DefaultTypeParameter(IClass targetClass, string name, int index) { this.targetClass = targetClass; diff --git a/src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs index b969419a59..049ef7719d 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs @@ -31,12 +31,6 @@ namespace ICSharpCode.SharpDevelop.Dom return typeParameter.Equals(rt.typeParameter); } - public override bool IsDefaultReturnType { - get { - return false; - } - } - public override int GetHashCode() { return typeParameter.GetHashCode(); @@ -85,7 +79,7 @@ namespace ICSharpCode.SharpDevelop.Dom get { int count = typeParameter.Constraints.Count; if (count == 0) - return ReflectionReturnType.Object; + return typeParameter.Class.ProjectContent.SystemTypes.Object; if (count == 1) return typeParameter.Constraints[0]; return new CombinedReturnType(typeParameter.Constraints, @@ -116,5 +110,28 @@ namespace ICSharpCode.SharpDevelop.Dom { return String.Format("[GenericReturnType: {0}]", typeParameter); } + + public override bool IsArrayReturnType { + get { + return false; + } + } + + public override bool IsConstructedReturnType { + get { + return false; + } + } + + public override bool IsGenericReturnType { + get { + return true; + } + } + + public override ICSharpCode.SharpDevelop.Dom.GenericReturnType CastToGenericReturnType() + { + return this; + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs b/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs index 4493dd3897..a4078a218c 100644 --- a/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs @@ -86,42 +86,6 @@ namespace ICSharpCode.SharpDevelop.Dom } } - public virtual int ArrayDimensions { - get { - IReturnType baseType = BaseType; - int tmp = (baseType != null && TryEnter()) ? baseType.ArrayDimensions : 0; - busy = false; - return tmp; - } - } - - public virtual IReturnType ArrayElementType { - get { - IReturnType baseType = BaseType; - IReturnType tmp = (baseType != null && TryEnter()) ? baseType.ArrayElementType : null; - busy = false; - return tmp; - } - } - - public virtual IReturnType UnboundType { - get { - IReturnType baseType = BaseType; - IReturnType tmp = (baseType != null && TryEnter()) ? baseType.UnboundType : null; - busy = false; - return tmp; - } - } - - public virtual IList TypeArguments { - get { - IReturnType baseType = BaseType; - IList tmp = (baseType != null && TryEnter()) ? baseType.TypeArguments : null; - busy = false; - return tmp; - } - } - public virtual IClass GetUnderlyingClass() { IReturnType baseType = BaseType; @@ -170,5 +134,65 @@ namespace ICSharpCode.SharpDevelop.Dom return tmp; } } + + public virtual bool IsArrayReturnType { + get { + IReturnType baseType = BaseType; + bool tmp = (baseType != null && TryEnter()) ? baseType.IsArrayReturnType : false; + busy = false; + return tmp; + } + } + public virtual ArrayReturnType CastToArrayReturnType() + { + IReturnType baseType = BaseType; + ArrayReturnType temp; + if (baseType != null && TryEnter()) + temp = CastToArrayReturnType(); + else + throw new InvalidCastException("Cannot cast " + ToString() + " to expected type."); + busy = false; + return temp; + } + + public virtual bool IsGenericReturnType { + get { + IReturnType baseType = BaseType; + bool tmp = (baseType != null && TryEnter()) ? baseType.IsGenericReturnType : false; + busy = false; + return tmp; + } + } + public virtual GenericReturnType CastToGenericReturnType() + { + IReturnType baseType = BaseType; + GenericReturnType temp; + if (baseType != null && TryEnter()) + temp = CastToGenericReturnType(); + else + throw new InvalidCastException("Cannot cast " + ToString() + " to expected type."); + busy = false; + return temp; + } + + public virtual bool IsConstructedReturnType { + get { + IReturnType baseType = BaseType; + bool tmp = (baseType != null && TryEnter()) ? baseType.IsConstructedReturnType : false; + busy = false; + return tmp; + } + } + public virtual ConstructedReturnType CastToConstructedReturnType() + { + IReturnType baseType = BaseType; + ConstructedReturnType temp; + if (baseType != null && TryEnter()) + temp = CastToConstructedReturnType(); + else + throw new InvalidCastException("Cannot cast " + ToString() + " to expected type."); + busy = false; + return temp; + } } } diff --git a/src/Main/Base/Project/Src/Dom/Implementations/SystemTypes.cs b/src/Main/Base/Project/Src/Dom/Implementations/SystemTypes.cs new file mode 100644 index 0000000000..b9471b09f0 --- /dev/null +++ b/src/Main/Base/Project/Src/Dom/Implementations/SystemTypes.cs @@ -0,0 +1,128 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Generic; +using ICSharpCode.Core; + +namespace ICSharpCode.SharpDevelop.Dom +{ + public class SystemTypes + { + public readonly IReturnType Void = VoidReturnType.Instance; + public readonly IReturnType Object; + public readonly IReturnType Delegate; + public readonly IReturnType ValueType; + public readonly IReturnType Enum; + + public readonly IReturnType Boolean; + public readonly IReturnType Int32; + public readonly IReturnType String; + + public readonly IReturnType Array; + public readonly IReturnType Attribute; + public readonly IReturnType Type; + + public readonly IReturnType AsyncCallback; + public readonly IReturnType IAsyncResult; + + IProjectContent pc; + + public SystemTypes(IProjectContent pc) + { + this.pc = pc; + Object = CreateFromName("System.Object"); + Delegate = CreateFromName("System.Delegate"); + ValueType = CreateFromName("System.ValueType"); + Enum = CreateFromName("System.Enum"); + + Boolean = CreateFromName("System.Boolean"); + Int32 = CreateFromName("System.Int32"); + String = CreateFromName("System.String"); + + Array = CreateFromName("System.Array"); + Attribute = CreateFromName("System.Attribute"); + Type = CreateFromName("System.Type"); + + AsyncCallback = CreateFromName("System.AsyncCallback"); + IAsyncResult = CreateFromName("System.IAsyncResult"); + } + + IReturnType CreateFromName(string name) + { + IClass c = pc.GetClass(name, 0); + if (c != null) { + return c.DefaultReturnType; + } else { + LoggingService.Warn("SystemTypes.CreateFromName could not find " + name); + return VoidReturnType.Instance; + } + } + + /// + /// Creates the return type for a primitive system type. + /// + public IReturnType CreatePrimitive(Type type) + { + if (type.HasElementType || type.ContainsGenericParameters) { + throw new ArgumentException("Only primitive types are supported."); + } + return CreateFromName(type.FullName); + } + } + + public class VoidClass : DefaultClass + { + public static readonly VoidClass Instance = new VoidClass(); + + internal static readonly string VoidName = typeof(void).FullName; + + public VoidClass() : base(DefaultCompilationUnit.DummyCompilationUnit, VoidName) + { + } + + protected override IReturnType CreateDefaultReturnType() + { + return VoidReturnType.Instance; + } + } + + public class VoidReturnType : AbstractReturnType + { + public static readonly VoidReturnType Instance = new VoidReturnType(); + + public VoidReturnType() + { + FullyQualifiedName = VoidClass.VoidName; + } + + public override IClass GetUnderlyingClass() + { + return VoidClass.Instance; + } + + public override List GetMethods() + { + return new List(); + } + + public override List GetProperties() + { + return new List(); + } + + public override List GetFields() + { + return new List(); + } + + public override List GetEvents() + { + return new List(); + } + } +} diff --git a/src/Main/Base/Project/Src/Dom/MemberLookupHelper.cs b/src/Main/Base/Project/Src/Dom/MemberLookupHelper.cs index 1b7118c4c4..d980be8628 100644 --- a/src/Main/Base/Project/Src/Dom/MemberLookupHelper.cs +++ b/src/Main/Base/Project/Src/Dom/MemberLookupHelper.cs @@ -241,8 +241,8 @@ namespace ICSharpCode.SharpDevelop.Dom if (j < parameters.Count) { IParameter parameter = parameters[j]; if (parameter.IsParams && needToExpand[i]) { - if (parameter.ReturnType.ArrayDimensions > 0) { - paramsType = parameter.ReturnType.ArrayElementType; + if (parameter.ReturnType.IsArrayReturnType) { + paramsType = parameter.ReturnType.CastToArrayReturnType().ArrayElementType; paramsType = ConstructedReturnType.TranslateType(paramsType, typeParameters, true); } expandedParameters[i][j] = paramsType; @@ -350,14 +350,14 @@ namespace ICSharpCode.SharpDevelop.Dom if (r == null && s == null) return 0; if (r == null) return 2; if (s == null) return 1; - if (r is GenericReturnType && !(s is GenericReturnType)) + if (r.IsGenericReturnType && !(s.IsGenericReturnType)) return 2; - if (s is GenericReturnType && !(r is GenericReturnType)) + if (s.IsGenericReturnType && !(r.IsGenericReturnType)) return 1; - if (r.ArrayDimensions > 0 && s.ArrayDimensions > 0) - return GetMoreSpecific(r.ArrayElementType, s.ArrayElementType); - if (r.TypeArguments != null && s.TypeArguments != null) - return GetMoreSpecific(r.TypeArguments, s.TypeArguments); + if (r.IsArrayReturnType && s.IsArrayReturnType) + return GetMoreSpecific(r.CastToArrayReturnType().ArrayElementType, s.CastToArrayReturnType().ArrayElementType); + if (r.IsConstructedReturnType && s.IsConstructedReturnType) + return GetMoreSpecific(r.CastToConstructedReturnType().TypeArguments, s.CastToConstructedReturnType().TypeArguments); return 0; } #endregion @@ -375,8 +375,11 @@ namespace ICSharpCode.SharpDevelop.Dom break; if (!InferTypeArgument(parameters[i].ReturnType, arguments[i], result)) { // inferring failed: maybe this is a params parameter that must be expanded? - if (parameters[i].IsParams && parameters[i].ReturnType.ArrayDimensions == 1) { - InferTypeArgument(parameters[i].ReturnType.ArrayElementType, arguments[i], result); + if (parameters[i].IsParams && parameters[i].ReturnType.IsArrayReturnType) { + ArrayReturnType art = parameters[i].ReturnType.CastToArrayReturnType(); + if (art.ArrayDimensions == 1) { + InferTypeArgument(art.ArrayElementType, arguments[i], result); + } } } } @@ -389,18 +392,26 @@ namespace ICSharpCode.SharpDevelop.Dom return null; } + /// + /// Infers type arguments specified by passing expectedArgument as parameter where passedArgument + /// was expected. The resulting type arguments are written to outputArray. + /// Returns false when expectedArgument and passedArgument are incompatible, otherwise true + /// is returned (true is used both for successful inferring and other kind of errors). + /// public static bool InferTypeArgument(IReturnType expectedArgument, IReturnType passedArgument, IReturnType[] outputArray) { + if (expectedArgument == null) return true; if (passedArgument == null) return true; // TODO: NullTypeReference - if (expectedArgument != null && expectedArgument.ArrayDimensions > 0) { - if (expectedArgument.ArrayDimensions == passedArgument.ArrayDimensions) { - return InferTypeArgument(expectedArgument.ArrayElementType, passedArgument.ArrayElementType, outputArray); - } else if (passedArgument.TypeArguments != null) { + if (expectedArgument.IsArrayReturnType) { + IReturnType expectedArrayElementType = expectedArgument.CastToArrayReturnType().ArrayElementType; + if (passedArgument.IsArrayReturnType && expectedArgument.CastToArrayReturnType().ArrayDimensions == passedArgument.CastToArrayReturnType().ArrayDimensions) { + return InferTypeArgument(expectedArrayElementType, passedArgument.CastToArrayReturnType().ArrayElementType, outputArray); + } else if (passedArgument.IsConstructedReturnType) { switch (passedArgument.FullyQualifiedName) { case "System.Collections.Generic.IList": case "System.Collections.Generic.ICollection": case "System.Collections.Generic.IEnumerable": - return InferTypeArgument(expectedArgument.ArrayElementType, passedArgument.TypeArguments[0], outputArray); + return InferTypeArgument(expectedArrayElementType, passedArgument.CastToConstructedReturnType().TypeArguments[0], outputArray); } } // If P is an array type, and A is not an array type of the same rank, @@ -408,20 +419,26 @@ namespace ICSharpCode.SharpDevelop.Dom // type inference fails for the generic method. return false; } - GenericReturnType methodTP = expectedArgument as GenericReturnType; - if (methodTP != null && methodTP.TypeParameter.Method != null) { - if (methodTP.TypeParameter.Index < outputArray.Length) { - outputArray[methodTP.TypeParameter.Index] = passedArgument; + if (expectedArgument.IsGenericReturnType) { + GenericReturnType methodTP = expectedArgument.CastToGenericReturnType(); + if (methodTP.TypeParameter.Method != null) { + if (methodTP.TypeParameter.Index < outputArray.Length) { + outputArray[methodTP.TypeParameter.Index] = passedArgument; + } + return true; } - return true; } - if (expectedArgument.TypeArguments != null) { + if (expectedArgument.IsConstructedReturnType) { // The spec for this case is quite complex. // For our purposes, we can simplify enourmously: - if (passedArgument.TypeArguments == null) return false; - int count = Math.Min(expectedArgument.TypeArguments.Count, passedArgument.TypeArguments.Count); + if (!passedArgument.IsConstructedReturnType) return false; + + IList expectedTA = expectedArgument.CastToConstructedReturnType().TypeArguments; + IList passedTA = passedArgument.CastToConstructedReturnType().TypeArguments; + + int count = Math.Min(expectedTA.Count, passedTA.Count); for (int i = 0; i < count; i++) { - InferTypeArgument(expectedArgument.TypeArguments[i], passedArgument.TypeArguments[i], outputArray); + InferTypeArgument(expectedTA[i], passedTA[i], outputArray); } } return true; @@ -474,11 +491,11 @@ namespace ICSharpCode.SharpDevelop.Dom // - all additional parameters must be applicable to the unpacked array IReturnType rt = parameters[lastParameter].ReturnType; - if (rt == null || rt.ArrayDimensions == 0) { + if (rt == null || !rt.IsArrayReturnType) { return false; } for (int i = lastParameter; i < arguments.Length; i++) { - if (IsApplicable(arguments[i], rt.ArrayElementType)) { + if (IsApplicable(arguments[i], rt.CastToArrayReturnType().ArrayElementType)) { score++; } else { ok = false; @@ -548,28 +565,33 @@ namespace ICSharpCode.SharpDevelop.Dom if (toIsDefault && to.FullyQualifiedName == "System.Object") { return true; // from any type to object } - if (toIsDefault && (fromIsDefault || from.ArrayDimensions > 0)) { + if (toIsDefault && (fromIsDefault || from.IsArrayReturnType)) { IClass c1 = from.GetUnderlyingClass(); IClass c2 = to.GetUnderlyingClass(); if (c1 != null && c1.IsTypeInInheritanceTree(c2)) { return true; } } - if (from.ArrayDimensions > 0 && from.ArrayDimensions == to.ArrayDimensions) { + if (from.IsArrayReturnType && to.IsArrayReturnType) { + ArrayReturnType fromArt = from.CastToArrayReturnType(); + ArrayReturnType toArt = to.CastToArrayReturnType(); // from array to other array type - return ConversionExists(from.ArrayElementType, to.ArrayElementType); + if (fromArt.ArrayDimensions == toArt.ArrayDimensions) { + return ConversionExists(fromArt.ArrayElementType, toArt.ArrayElementType); + } } - IList fromTypeArguments = from.TypeArguments; - IList toTypeArguments = to.TypeArguments; - if (fromTypeArguments != null && toTypeArguments != null) { + + if (from.IsConstructedReturnType && to.IsConstructedReturnType) { if (from.FullyQualifiedName == to.FullyQualifiedName) { + IList fromTypeArguments = from.CastToConstructedReturnType().TypeArguments; + IList toTypeArguments = to.CastToConstructedReturnType().TypeArguments; if (fromTypeArguments.Count == toTypeArguments.Count) { for (int i = 0; i < fromTypeArguments.Count; i++) { if (fromTypeArguments[i] == toTypeArguments[i]) continue; if (object.Equals(fromTypeArguments[i], toTypeArguments[i])) continue; - if (!(toTypeArguments[i] is GenericReturnType)) + if (!(toTypeArguments[i].IsGenericReturnType)) return false; } return true; @@ -690,8 +712,10 @@ namespace ICSharpCode.SharpDevelop.Dom /// /// Gets the common base type of a and b. /// - public static IReturnType GetCommonType(IReturnType a, IReturnType b) + public static IReturnType GetCommonType(IProjectContent projectContent, IReturnType a, IReturnType b) { + if (projectContent == null) + throw new ArgumentNullException("projectContent"); if (a == null) return b; if (b == null) return a; if (ConversionExists(a, b)) @@ -713,7 +737,7 @@ namespace ICSharpCode.SharpDevelop.Dom return baseType; } } - return ReflectionReturnType.Object; + return projectContent.SystemTypes.Object; } /// @@ -721,20 +745,26 @@ namespace ICSharpCode.SharpDevelop.Dom /// For example, when is Dictionary(of string, int) /// this method will return KeyValuePair(of string, int) /// - public static IReturnType GetTypeParameterPassedToBaseClass(IReturnType returnType, IClass baseClass, int baseClassTypeParameterIndex) + public static IReturnType GetTypeParameterPassedToBaseClass(IReturnType parentType, IClass baseClass, int baseClassTypeParameterIndex) { + if (!parentType.IsConstructedReturnType) + return null; + ConstructedReturnType returnType = parentType.CastToConstructedReturnType(); IClass c = returnType.GetUnderlyingClass(); if (c == null) return null; if (baseClass.CompareTo(c) == 0) { - if (returnType.TypeArguments == null || baseClassTypeParameterIndex >= returnType.TypeArguments.Count) + if (baseClassTypeParameterIndex >= returnType.TypeArguments.Count) return null; return returnType.TypeArguments[baseClassTypeParameterIndex]; } foreach (IReturnType baseType in c.BaseTypes) { if (baseClass.CompareTo(baseType.GetUnderlyingClass()) == 0) { - if (baseType.TypeArguments == null || baseClassTypeParameterIndex >= baseType.TypeArguments.Count) + if (!baseType.IsConstructedReturnType) + return null; + ConstructedReturnType baseTypeCRT = baseType.CastToConstructedReturnType(); + if (baseClassTypeParameterIndex >= baseTypeCRT.TypeArguments.Count) return null; - IReturnType result = baseType.TypeArguments[baseClassTypeParameterIndex]; + IReturnType result = baseTypeCRT.TypeArguments[baseClassTypeParameterIndex]; if (returnType.TypeArguments != null) { result = ConstructedReturnType.TranslateType(result, returnType.TypeArguments, false); } diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs index 7dd853a1da..98dbc1c2b0 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs @@ -380,7 +380,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver void CreateDelegate(DefaultClass c, string name, AST.TypeReference returnType, IList templates, IList parameters) { - c.BaseTypes.Add(ReflectionReturnType.CreatePrimitive(typeof(Delegate))); + c.BaseTypes.Add(c.ProjectContent.SystemTypes.Delegate); if (currentClass.Count > 0) { DefaultClass cur = GetCurrentClass(); cur.InnerClasses.Add(c); diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs index f832c02199..c1bbfe6568 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs @@ -282,7 +282,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver return null; IClass c = SearchClass(name); if (c != null) { - if (c.IsTypeInInheritanceTree(ProjectContentRegistry.Mscorlib.GetClass("System.Attribute"))) + if (c.IsTypeInInheritanceTree(c.ProjectContent.SystemTypes.Attribute.GetUnderlyingClass())) return c; } return SearchClass(name + "Attribute"); @@ -318,7 +318,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (expr is PrimitiveExpression) { if (((PrimitiveExpression)expr).Value is int) - return new IntegerLiteralResolveResult(callingClass, callingMember); + return new IntegerLiteralResolveResult(callingClass, callingMember, projectContent.SystemTypes.Int32); } else if (expr is InvocationExpression) { IMethodOrProperty method = typeVisitor.GetMethod(expr as InvocationExpression); if (method != null) { @@ -400,9 +400,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } } IReturnType[] typeParameters = null; - if (type.TypeArguments != null) { - typeParameters = new IReturnType[type.TypeArguments.Count]; - type.TypeArguments.CopyTo(typeParameters, 0); + if (type.IsConstructedReturnType) { + typeParameters = new IReturnType[type.CastToConstructedReturnType().TypeArguments.Count]; + type.CastToConstructedReturnType().TypeArguments.CopyTo(typeParameters, 0); } ResolveResult rr = CreateMemberResolveResult(typeVisitor.FindOverload(constructors, typeParameters, ((ObjectCreateExpression)expr).Parameters, null)); if (rr != null) { diff --git a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs index 9cce8ea239..45d80158e4 100644 --- a/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs +++ b/src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs @@ -30,7 +30,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver if (primitiveExpression.Value == null) { return NullReturnType.Instance; } else { - return ReflectionReturnType.CreatePrimitive(primitiveExpression.Value.GetType()); + return resolver.ProjectContent.SystemTypes.CreatePrimitive(primitiveExpression.Value.GetType()); } } @@ -40,9 +40,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver case BinaryOperatorType.NullCoalescing: return binaryOperatorExpression.Right.AcceptVisitor(this, data); case BinaryOperatorType.DivideInteger: - return ReflectionReturnType.Int; + return resolver.ProjectContent.SystemTypes.Int32; case BinaryOperatorType.Concat: - return ReflectionReturnType.String; + return resolver.ProjectContent.SystemTypes.String; case BinaryOperatorType.Equality: case BinaryOperatorType.InEquality: case BinaryOperatorType.ReferenceEquality: @@ -53,9 +53,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver case BinaryOperatorType.LessThanOrEqual: case BinaryOperatorType.GreaterThan: case BinaryOperatorType.GreaterThanOrEqual: - return ReflectionReturnType.Bool; + return resolver.ProjectContent.SystemTypes.Boolean; default: - return MemberLookupHelper.GetCommonType(binaryOperatorExpression.Left.AcceptVisitor(this, data) as IReturnType, + return MemberLookupHelper.GetCommonType(resolver.ProjectContent, + binaryOperatorExpression.Left.AcceptVisitor(this, data) as IReturnType, binaryOperatorExpression.Right.AcceptVisitor(this, data) as IReturnType); } } @@ -348,12 +349,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(SizeOfExpression sizeOfExpression, object data) { - return CreateReturnType(typeof(int)); + return resolver.ProjectContent.SystemTypes.Int32; } public override object Visit(TypeOfExpression typeOfExpression, object data) { - return CreateReturnType(typeof(Type)); + return resolver.ProjectContent.SystemTypes.Type; } public override object Visit(CheckedExpression checkedExpression, object data) @@ -415,7 +416,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver public override object Visit(TypeOfIsExpression typeOfIsExpression, object data) { - return ReflectionReturnType.Bool; + return resolver.ProjectContent.SystemTypes.Boolean; } public override object Visit(DefaultValueExpression defaultValueExpression, object data) @@ -532,14 +533,14 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver } t = new ConstructedReturnType(t, para); } - return WrapArray(t, reference); + return WrapArray(projectContent, t, reference); } - static IReturnType WrapArray(IReturnType t, TypeReference reference) + static IReturnType WrapArray(IProjectContent pc, IReturnType t, TypeReference reference) { if (reference.IsArrayType) { for (int i = reference.RankSpecifier.Length - 1; i >= 0; --i) { - t = new ArrayReturnType(t, reference.RankSpecifier[i] + 1); + t = new ArrayReturnType(pc, t, reference.RankSpecifier[i] + 1); } } return t; @@ -572,10 +573,5 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver return new List(); } } - - static IReturnType CreateReturnType(Type type) - { - return ReflectionReturnType.Create(ProjectContentRegistry.Mscorlib, null, type, false); - } } } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/DomPersistence.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/DomPersistence.cs index 662b3b665c..f87c066b60 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/DomPersistence.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/DomPersistence.cs @@ -530,11 +530,11 @@ namespace ICSharpCode.SharpDevelop.Dom } } else if (rt is GenericReturnType) { // ignore - } else if (rt.ArrayDimensions > 0) { - AddExternalType(rt.ArrayElementType, externalTypes, classCount); - } else if (rt.TypeArguments != null) { - AddExternalType(rt.UnboundType, externalTypes, classCount); - foreach (IReturnType typeArgument in rt.TypeArguments) { + } else if (rt.IsArrayReturnType) { + AddExternalType(rt.CastToArrayReturnType().ArrayElementType, externalTypes, classCount); + } else if (rt.IsConstructedReturnType) { + AddExternalType(rt.CastToConstructedReturnType().UnboundType, externalTypes, classCount); + foreach (IReturnType typeArgument in rt.CastToConstructedReturnType().TypeArguments) { AddExternalType(typeArgument, externalTypes, classCount); } } else { @@ -562,23 +562,24 @@ namespace ICSharpCode.SharpDevelop.Dom } else { writer.Write(classIndices[new ClassNameTypeCountPair(rt)]); } - } else if (rt is GenericReturnType) { - GenericReturnType grt = (GenericReturnType)rt; + } else if (rt.IsGenericReturnType) { + GenericReturnType grt = rt.CastToGenericReturnType(); if (grt.TypeParameter.Method != null) { writer.Write(MethodGenericRTCode); } else { writer.Write(TypeGenericRTCode); } writer.Write(grt.TypeParameter.Index); - } else if (rt.ArrayDimensions > 0) { + } else if (rt.IsArrayReturnType) { writer.Write(ArrayRTCode); - writer.Write(rt.ArrayDimensions); - WriteType(rt.ArrayElementType); - } else if (rt.TypeArguments != null) { + writer.Write(rt.CastToArrayReturnType().ArrayDimensions); + WriteType(rt.CastToArrayReturnType().ArrayElementType); + } else if (rt.IsConstructedReturnType) { + ConstructedReturnType crt = rt.CastToConstructedReturnType(); writer.Write(ConstructedRTCode); - WriteType(rt.UnboundType); - writer.Write((byte)rt.TypeArguments.Count); - foreach (IReturnType typeArgument in rt.TypeArguments) { + WriteType(crt.UnboundType); + writer.Write((byte)crt.TypeArguments.Count); + foreach (IReturnType typeArgument in crt.TypeArguments) { WriteType(typeArgument); } } else { @@ -594,7 +595,7 @@ namespace ICSharpCode.SharpDevelop.Dom switch (index) { case ArrayRTCode: int dimensions = reader.ReadInt32(); - return new ArrayReturnType(ReadType(), dimensions); + return new ArrayReturnType(pc, ReadType(), dimensions); case ConstructedRTCode: IReturnType baseType = ReadType(); IReturnType[] typeArguments = new IReturnType[reader.ReadByte()]; @@ -609,7 +610,7 @@ namespace ICSharpCode.SharpDevelop.Dom case NullRTReferenceCode: return null; case VoidRTCode: - return ReflectionReturnType.Void; + return VoidReturnType.Instance; default: return types[index]; } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs index 6ea24a2b94..73f757f266 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionClass.cs @@ -11,7 +11,7 @@ using System.Reflection; using System.Collections.Generic; using ICSharpCode.Core; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { [Serializable] public class ReflectionClass : DefaultClass @@ -123,7 +123,7 @@ namespace ICSharpCode.SharpDevelop.Dom } int i = 0; foreach (Type g in type.GetGenericArguments()) { - ((DefaultTypeParameter)this.TypeParameters[i++]).AddConstraintsFromType(g); + AddConstraintsFromType(this.TypeParameters[i++], g); } } @@ -164,6 +164,17 @@ namespace ICSharpCode.SharpDevelop.Dom InitMembers(type); } + + internal void AddConstraintsFromType(ITypeParameter tp, Type type) + { + foreach (Type constraint in type.GetGenericParameterConstraints()) { + if (tp.Method != null) { + tp.Constraints.Add(ReflectionReturnType.Create(tp.Method, constraint, false)); + } else { + tp.Constraints.Add(ReflectionReturnType.Create(tp.Class, constraint, false)); + } + } + } } } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs index 5685220a62..dac8759edd 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionEvent.cs @@ -10,7 +10,7 @@ using System.Collections; using System.Reflection; using System.Xml; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { [Serializable] public class ReflectionEvent : DefaultEvent diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs index 900a50dd23..aad2ad500d 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionField.cs @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Reflection; using System.Xml; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { [Serializable] public class ReflectionField : DefaultField diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionLoader.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionLoader.cs index 09896f72df..27c7db0119 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionLoader.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionLoader.cs @@ -10,7 +10,7 @@ using System.IO; using System.Reflection; using ICSharpCode.Core; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { public sealed class ReflectionLoader : MarshalByRefObject { diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs index d22572d4a9..43c3ae1de4 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs @@ -12,12 +12,12 @@ using System.Collections.Generic; using System.Reflection; using System.Xml; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { [Serializable] public class ReflectionMethod : DefaultMethod { - public ReflectionMethod(MethodBase methodBase, IClass declaringType) + public ReflectionMethod(MethodBase methodBase, ReflectionClass declaringType) : base(declaringType, methodBase is ConstructorInfo ? "#ctor" : methodBase.Name) { if (methodBase is MethodInfo) { @@ -36,7 +36,7 @@ namespace ICSharpCode.SharpDevelop.Dom } int i = 0; foreach (Type g in methodBase.GetGenericArguments()) { - ((DefaultTypeParameter)this.TypeParameters[i++]).AddConstraintsFromType(g); + declaringType.AddConstraintsFromType(this.TypeParameters[i++], g); } } diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs index d6295cdc5b..984310c456 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs @@ -10,7 +10,7 @@ using System.Reflection; using System.Xml; using ICSharpCode.Core; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { [Serializable] public class ReflectionParameter : DefaultParameter diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs index 628f4bfeb5..f622cca78c 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionProperty.cs @@ -10,7 +10,7 @@ using System.Collections; using System.Reflection; using System.Xml; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { [Serializable] public class ReflectionProperty : DefaultProperty diff --git a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs index 652c97c91e..7abd409664 100644 --- a/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs +++ b/src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs @@ -9,136 +9,10 @@ using System; using System.Collections.Generic; using ICSharpCode.Core; -namespace ICSharpCode.SharpDevelop.Dom +namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer { public static class ReflectionReturnType { - #region Primitive Types - static IReturnType @object, @int, @string, @bool, type, @void, array, disposable, exception, @delegate; - - /// Gets a ReturnType describing System.Object. - public static IReturnType Object { - get { - if (@object == null) { - @object = CreatePrimitive(typeof(object)); - } - return @object; - } - } - /// Gets a ReturnType describing System.Int32. - public static IReturnType Int { - get { - if (@int == null) { - @int = CreatePrimitive(typeof(int)); - } - return @int; - } - } - /// Gets a ReturnType describing System.String. - public static IReturnType String { - get { - if (@string == null) { - @string = CreatePrimitive(typeof(string)); - } - return @string; - } - } - /// Gets a ReturnType describing System.Boolean. - public static IReturnType Bool { - get { - if (@bool == null) { - @bool = CreatePrimitive(typeof(bool)); - } - return @bool; - } - } - /// Gets a ReturnType describing System.Type. - public static IReturnType Type { - get { - if (type == null) { - type = CreatePrimitive(typeof(Type)); - } - return type; - } - } - /// Gets a ReturnType describing System.Array. - public static IReturnType Array { - get { - if (array == null) { - array = CreatePrimitive(typeof(Array)); - } - return array; - } - } - /// Gets a ReturnType describing System.IDisposable. - public static IReturnType Disposable { - get { - if (disposable == null) { - disposable = CreatePrimitive(typeof(IDisposable)); - } - return disposable; - } - } - /// Gets a ReturnType describing System.IDisposable. - public static IReturnType Exception { - get { - if (exception == null) { - exception = CreatePrimitive(typeof(Exception)); - } - return exception; - } - } - - /// Gets a ReturnType describing System.Delegate. - public static IReturnType Delegate { - get { - if (@delegate == null) { - @delegate = CreatePrimitive(typeof(Delegate)); - } - return @delegate; - } - } - /// Gets a ReturnType describing System.Void. - public static IReturnType Void { - get { - if (@void == null) { - @void = new VoidReturnType(); - } - return @void; - } - } - private class VoidReturnType : AbstractReturnType - { - public VoidReturnType() { - FullyQualifiedName = typeof(void).FullName; - } - public override IClass GetUnderlyingClass() { - return ProjectContentRegistry.Mscorlib.GetClass(FullyQualifiedName); - } - public override List GetMethods() { - return new List(); - } - public override List GetProperties() { - return new List(); - } - public override List GetFields() { - return new List(); - } - public override List GetEvents() { - return new List(); - } - } - - /// - /// Create a primitive return type. - /// Allowed are ONLY simple classes from MsCorlib (no arrays/generics etc.) - /// - public static IReturnType CreatePrimitive(Type type) - { - return ProjectContentRegistry.Mscorlib.GetClass(type.FullName).DefaultReturnType; - } - #endregion - public static bool IsDefaultType(Type type) { return !type.IsArray && !type.IsGenericType && !type.IsGenericParameter; @@ -160,7 +34,7 @@ namespace ICSharpCode.SharpDevelop.Dom // TODO: Use ByRefRefReturnType return Create(pc, member, type.GetElementType(), createLazyReturnType); } else if (type.IsArray) { - return MakeArray(type, Create(pc, member, type.GetElementType(), createLazyReturnType)); + return new ArrayReturnType(pc, Create(pc, member, type.GetElementType(), createLazyReturnType), type.GetArrayRank()); } else if (type.IsGenericType && !type.IsGenericTypeDefinition) { Type[] args = type.GetGenericArguments(); List para = new List(args.Length); @@ -209,10 +83,5 @@ namespace ICSharpCode.SharpDevelop.Dom return new GetClassReturnType(pc, name, typeParameterCount); } } - - static IReturnType MakeArray(Type type, IReturnType baseType) - { - return new ArrayReturnType(baseType, type.GetArrayRank()); - } } } diff --git a/src/Main/Base/Project/Src/Dom/ResolveResult.cs b/src/Main/Base/Project/Src/Dom/ResolveResult.cs index 7797114e67..f0e4f363e8 100644 --- a/src/Main/Base/Project/Src/Dom/ResolveResult.cs +++ b/src/Main/Base/Project/Src/Dom/ResolveResult.cs @@ -124,7 +124,7 @@ namespace ICSharpCode.SharpDevelop.Dom bool supportsExtensionProperties = language.SupportsExtensionProperties; if (supportsExtensionMethods || supportsExtensionProperties) { ArrayList list = new ArrayList(); - IMethod dummyMethod = new DefaultMethod("dummy", ReflectionReturnType.Void, ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, callingClass); + IMethod dummyMethod = new DefaultMethod("dummy", VoidReturnType.Instance, ModifierEnum.Static, DomRegion.Empty, DomRegion.Empty, callingClass); NRefactoryResolver.NRefactoryResolver.AddContentsFromCalling(list, callingClass, dummyMethod); NRefactoryResolver.NRefactoryResolver.AddImportedNamespaceContents(list, callingClass.CompilationUnit, callingClass); @@ -367,8 +367,8 @@ namespace ICSharpCode.SharpDevelop.Dom /// public class IntegerLiteralResolveResult : ResolveResult { - public IntegerLiteralResolveResult(IClass callingClass, IMember callingMember) - : base(callingClass, callingMember, ReflectionReturnType.Int) + public IntegerLiteralResolveResult(IClass callingClass, IMember callingMember, IReturnType systemInt32) + : base(callingClass, callingMember, systemInt32) { } diff --git a/src/Main/Base/Project/Src/Gui/Pads/FileScout.cs b/src/Main/Base/Project/Src/Gui/Pads/FileScout.cs index 593c9794cc..0758586319 100644 --- a/src/Main/Base/Project/Src/Gui/Pads/FileScout.cs +++ b/src/Main/Base/Project/Src/Gui/Pads/FileScout.cs @@ -516,12 +516,12 @@ namespace ICSharpCode.SharpDevelop.Gui public ShellTree() { Sorted = true; - TreeNode rootNode = Nodes.Add("Desktop"); + TreeNode rootNode = Nodes.Add(Path.GetFileName(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory))); rootNode.ImageIndex = 6; rootNode.SelectedImageIndex = 6; rootNode.Tag = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory); - TreeNode myFilesNode = rootNode.Nodes.Add("My Documents"); + TreeNode myFilesNode = rootNode.Nodes.Add(Path.GetFileName(Environment.GetFolderPath(Environment.SpecialFolder.Personal))); myFilesNode.ImageIndex = 7; myFilesNode.SelectedImageIndex = 7; try { @@ -532,7 +532,7 @@ namespace ICSharpCode.SharpDevelop.Gui myFilesNode.Nodes.Add(""); - TreeNode computerNode = rootNode.Nodes.Add("My Computer"); + TreeNode computerNode = rootNode.Nodes.Add(StringParser.Parse("${res:MainWindow.Windows.FileScout.MyComputer}")); computerNode.ImageIndex = 8; computerNode.SelectedImageIndex = 8; try { diff --git a/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs b/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs index 21acaf6638..d3fd5c72cb 100644 --- a/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs +++ b/src/Main/Base/Project/Src/Services/AmbienceService/AmbienceReflectionDecorator.cs @@ -10,6 +10,7 @@ using System.Collections; using System.Reflection; using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.SharpDevelop.Dom.ReflectionLayer; namespace ICSharpCode.Core { diff --git a/src/Main/Base/Project/Src/Services/ParserService/DefaultProjectContent.cs b/src/Main/Base/Project/Src/Services/ParserService/DefaultProjectContent.cs index b68a8ba033..ea56deef2a 100644 --- a/src/Main/Base/Project/Src/Services/ParserService/DefaultProjectContent.cs +++ b/src/Main/Base/Project/Src/Services/ParserService/DefaultProjectContent.cs @@ -151,6 +151,21 @@ namespace ICSharpCode.Core } } + SystemTypes systemTypes; + + /// + /// Gets a class that allows to conveniently access commonly used types in the system + /// namespace. + /// + public virtual SystemTypes SystemTypes { + get { + if (systemTypes == null) { + systemTypes = new SystemTypes(this); + } + return systemTypes; + } + } + public ICollection ReferencedContents { get { return referencedContents; @@ -818,9 +833,26 @@ namespace ICSharpCode.Core protected virtual void OnReferencedContentsChanged(EventArgs e) { + systemTypes = null; // re-create system types if (ReferencedContentsChanged != null) { ReferencedContentsChanged(this, e); } } + + public static readonly IProjectContent DummyProjectContent = new DummyContent(); + + private class DummyContent : DefaultProjectContent + { + public override string ToString() + { + return "[DummyProjectContent]"; + } + + public override SystemTypes SystemTypes { + get { + return ParserService.CurrentProjectContent.SystemTypes; + } + } + } } } diff --git a/src/Main/Base/Project/Src/Services/ParserService/IProjectContent.cs b/src/Main/Base/Project/Src/Services/ParserService/IProjectContent.cs index e5acf5ebfd..f8804cf06b 100644 --- a/src/Main/Base/Project/Src/Services/ParserService/IProjectContent.cs +++ b/src/Main/Base/Project/Src/Services/ParserService/IProjectContent.cs @@ -55,6 +55,14 @@ namespace ICSharpCode.Core get; } + /// + /// Gets a class that allows to conveniently access commonly used types in the system + /// namespace. + /// + SystemTypes SystemTypes { + get; + } + string GetXmlDocumentation(string memberTag); void AddClassToNamespaceList(IClass addClass); diff --git a/src/Main/Base/Project/Src/Services/ParserService/ProjectContentRegistry.cs b/src/Main/Base/Project/Src/Services/ParserService/ProjectContentRegistry.cs index 00dfb7672f..d655b998ff 100644 --- a/src/Main/Base/Project/Src/Services/ParserService/ProjectContentRegistry.cs +++ b/src/Main/Base/Project/Src/Services/ParserService/ProjectContentRegistry.cs @@ -6,20 +6,17 @@ // using System; -using System.IO; -using System.Threading; -using System.Collections; using System.Collections.Generic; -using System.Diagnostics; +using System.IO; using System.Reflection; +using System.Text; using System.Windows.Forms; using System.Xml; -using System.Text; -using ICSharpCode.Core; -using ICSharpCode.SharpDevelop.Project; -using ICSharpCode.SharpDevelop.Gui; using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.SharpDevelop.Dom.ReflectionLayer; +using ICSharpCode.SharpDevelop.Gui; +using ICSharpCode.SharpDevelop.Project; using MSjogren.GacTool.FusionNative; namespace ICSharpCode.Core diff --git a/src/Main/Base/Project/Src/Services/ParserService/ReflectionProjectContent.cs b/src/Main/Base/Project/Src/Services/ParserService/ReflectionProjectContent.cs index ce885fd7f7..60c7108ea1 100644 --- a/src/Main/Base/Project/Src/Services/ParserService/ReflectionProjectContent.cs +++ b/src/Main/Base/Project/Src/Services/ParserService/ReflectionProjectContent.cs @@ -16,6 +16,7 @@ using System.Reflection; using ICSharpCode.SharpDevelop.Gui; using ICSharpCode.SharpDevelop.Project; using ICSharpCode.Core; +using ICSharpCode.SharpDevelop.Dom.ReflectionLayer; namespace ICSharpCode.SharpDevelop.Dom { @@ -102,18 +103,7 @@ namespace ICSharpCode.SharpDevelop.Dom public void InitializeSpecialClasses() { if (GetClassInternal(VoidClass.VoidName, 0, Language) != null) { - AddClassToNamespaceList(new VoidClass(assemblyCompilationUnit)); - } - } - - private class VoidClass : ReflectionClass - { - internal static readonly string VoidName = typeof(void).FullName; - - public VoidClass(ICompilationUnit compilationUnit) : base(compilationUnit, typeof(void), VoidName, null) {} - - protected override IReturnType CreateDefaultReturnType() { - return ReflectionReturnType.Void; + AddClassToNamespaceList(VoidClass.Instance); } } diff --git a/src/Main/Base/Project/Src/Services/RefactoringService/CodeGenerator.cs b/src/Main/Base/Project/Src/Services/RefactoringService/CodeGenerator.cs index e0c7421efb..6b77536f86 100644 --- a/src/Main/Base/Project/Src/Services/RefactoringService/CodeGenerator.cs +++ b/src/Main/Base/Project/Src/Services/RefactoringService/CodeGenerator.cs @@ -32,15 +32,15 @@ namespace ICSharpCode.SharpDevelop.Refactoring typeRef = new TypeReference(returnType.Name); else typeRef = new TypeReference(returnType.FullyQualifiedName); - while (returnType.ArrayDimensions > 0) { + while (returnType.IsArrayReturnType) { int[] rank = typeRef.RankSpecifier ?? new int[0]; Array.Resize(ref rank, rank.Length + 1); - rank[rank.Length - 1] = returnType.ArrayDimensions - 1; + rank[rank.Length - 1] = returnType.CastToArrayReturnType().ArrayDimensions - 1; typeRef.RankSpecifier = rank; - returnType = returnType.ArrayElementType; + returnType = returnType.CastToArrayReturnType().ArrayElementType; } - if (returnType.TypeArguments != null) { - foreach (IReturnType typeArgument in returnType.TypeArguments) { + if (returnType.IsConstructedReturnType) { + foreach (IReturnType typeArgument in returnType.CastToConstructedReturnType().TypeArguments) { typeRef.GenericTypes.Add(ConvertType(typeArgument, context)); } } @@ -71,9 +71,10 @@ namespace ICSharpCode.SharpDevelop.Refactoring case "System.UInt16": case "System.UInt32": case "System.UInt64": + // don't use short name -> output visitor will use the instrinsic name return false; } - int typeArgumentCount = (returnType.TypeArguments != null) ? returnType.TypeArguments.Count : 0; + int typeArgumentCount = (returnType.IsConstructedReturnType) ? returnType.CastToConstructedReturnType().TypeArguments.Count : 0; IReturnType typeInTargetContext = context.SearchType(returnType.Name, typeArgumentCount); return typeInTargetContext != null && typeInTargetContext.FullyQualifiedName == returnType.FullyQualifiedName; }