Fixed bugs loading method modifiers from Reflection/Cecil.

Rewrote IReturnType-output in CSharpAmbience to support inner classes inside generic classes.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/3.0@4954 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/Main/Base/Test/ReflectionLayerTests.cs

@@ -255,6 +255,59 @@ namespace ICSharpCode.SharpDevelop.Tests
 			Assert.AreSame(valueCollection, valueProperty.ReturnType.GetUnderlyingClass());
 		}
 		
+		[Test]
+		public void ValueCollectionCountModifiers()
+		{
+			IClass valueCollection = mscorlib.GetClass("System.Collections.Generic.Dictionary.ValueCollection", 2);
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Sealed, valueCollection.Modifiers);
+			IProperty count = valueCollection.Properties.Single(p => p.Name == "Count");
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Sealed, count.Modifiers);
+		}
+		
+		[Test]
+		public void MathAcosModifiers()
+		{
+			IClass math = mscorlib.GetClass("System.Math", 0);
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Abstract | ModifierEnum.Sealed | ModifierEnum.Static, math.Modifiers);
+			IMethod acos = math.Methods.Single(p => p.Name == "Acos");
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Static, acos.Modifiers);
+		}
+		
+		[Test]
+		public void EncodingModifiers()
+		{
+			IClass encoding = mscorlib.GetClass("System.Text.Encoding", 0);
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Abstract, encoding.Modifiers);
+			IMethod getDecoder = encoding.Methods.Single(p => p.Name == "GetDecoder");
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Virtual, getDecoder.Modifiers);
+			IMethod getMaxByteCount = encoding.Methods.Single(p => p.Name == "GetMaxByteCount");
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Abstract, getMaxByteCount.Modifiers);
+			IProperty encoderFallback = encoding.Properties.Single(p => p.Name == "EncoderFallback");
+			Assert.AreEqual(ModifierEnum.Public, encoderFallback.Modifiers);
+		}
+		
+		[Test]
+		public void UnicodeEncodingModifiers()
+		{
+			IClass encoding = mscorlib.GetClass("System.Text.UnicodeEncoding", 0);
+			Assert.AreEqual(ModifierEnum.Public, encoding.Modifiers);
+			IMethod getDecoder = encoding.Methods.Single(p => p.Name == "GetDecoder");
+			// Should be override, but actually is 'virtual'. We cannot do better because 'override' is not encoded in the metadata
+			// (the .override directive is unrelated; it's meant for explicit interface implementations)
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Virtual, getDecoder.Modifiers);
+		}
+		
+		[Test]
+		public void UTF32EncodingModifiers()
+		{
+			IClass encoding = mscorlib.GetClass("System.Text.UTF32Encoding", 0);
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Sealed, encoding.Modifiers);
+			IMethod getDecoder = encoding.Methods.Single(p => p.Name == "GetDecoder");
+			// Should be override, but actually is 'virtual'. We cannot do better because 'override' is not encoded in the metadata
+			// (the .override directive is unrelated; it's meant for explicit interface implementations)
+			Assert.AreEqual(ModifierEnum.Public | ModifierEnum.Virtual, getDecoder.Modifiers);
+		}
+		
 		public class TestClass<A, B> where A : B {
 			public void TestMethod<K, V>(string param) where V: K where K: IComparable {}
 			

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/CSharp/CSharpAmbience.cs

@@ -144,27 +144,7 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				}
 			}
 			
-			if (IncludeHtmlMarkup) {
-				builder.Append("<b>");
-			}
-			
-			if (UseFullyQualifiedMemberNames) {
-				builder.Append(c.FullyQualifiedName);
-			} else {
-				builder.Append(c.Name);
-			}
-			
-			if (IncludeHtmlMarkup) {
-				builder.Append("</b>");
-			}
-			if (ShowTypeParameterList && c.TypeParameters.Count > 0) {
-				builder.Append('<');
-				for (int i = 0; i < c.TypeParameters.Count; ++i) {
-					if (i > 0) builder.Append(", ");
-					builder.Append(ConvertTypeParameter(c.TypeParameters[i]));
-				}
-				builder.Append('>');
-			}
+			AppendClassNameWithTypeParameters(builder, c, UseFullyQualifiedMemberNames, true, null);
 			
 			if (ShowParameterList && c.ClassType == ClassType.Delegate) {
 				builder.Append(" (");
@@ -203,6 +183,42 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 			return builder.ToString();
 		}
 
+		void AppendClassNameWithTypeParameters(StringBuilder builder, IClass c, bool fullyQualified, bool isConvertingClassName, IList<IReturnType> typeArguments)
+		{
+			if (isConvertingClassName && IncludeHtmlMarkup) {
+				builder.Append("<b>");
+			}
+			if (fullyQualified) {
+				if (c.DeclaringType != null) {
+					AppendClassNameWithTypeParameters(builder, c.DeclaringType, fullyQualified, false, typeArguments);
+					builder.Append('.');
+					builder.Append(c.Name);
+				} else {
+					builder.Append(c.FullyQualifiedName);
+				}
+			} else {
+				builder.Append(c.Name);
+			}
+			if (isConvertingClassName && IncludeHtmlMarkup) {
+				builder.Append("</b>");
+			}
+			// skip type parameters that belong to declaring types (in DOM, inner classes repeat type parameters from outer classes)
+			int skippedTypeParameterCount = c.DeclaringType != null ? c.DeclaringType.TypeParameters.Count : 0;
+			// show type parameters for classes only if ShowTypeParameterList is set; but always show them in other cases.
+			if ((ShowTypeParameterList || !isConvertingClassName) && c.TypeParameters.Count > skippedTypeParameterCount) {
+				builder.Append('<');
+				for (int i = skippedTypeParameterCount; i < c.TypeParameters.Count; ++i) {
+					if (i > skippedTypeParameterCount)
+						builder.Append(", ");
+					if (typeArguments != null && i < typeArguments.Count)
+						AppendReturnType(builder, typeArguments[i], false);
+					else
+						builder.Append(ConvertTypeParameter(c.TypeParameters[i]));
+				}
+				builder.Append('>');
+			}
+		}
+		
 		public override string ConvertEnd(IClass c)
 		{
 			return "}";
@@ -247,15 +263,13 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				builder.Append(' ');
 			}
 			
+			AppendTypeNameForFullyQualifiedMemberName(builder, field.DeclaringTypeReference);
+			
 			if (IncludeHtmlMarkup) {
 				builder.Append("<b>");
 			}
 			
-			if (UseFullyQualifiedMemberNames) {
-				builder.Append(field.FullyQualifiedName);
-			} else {
 			builder.Append(field.Name);
-			}
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</b>");
@@ -283,21 +297,15 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				builder.Append(' ');
 			}
 			
+			AppendTypeNameForFullyQualifiedMemberName(builder, property.DeclaringTypeReference);
+			
 			if (property.IsIndexer) {
-				if (property.DeclaringType != null && UseFullyQualifiedMemberNames) {
-					builder.Append(property.DeclaringType.FullyQualifiedName);
-					builder.Append('.');
-				}
 				builder.Append("this");
 			} else {
 				if (IncludeHtmlMarkup) {
 					builder.Append("<b>");
 				}
-				if (UseFullyQualifiedMemberNames) {
-					builder.Append(property.FullyQualifiedName);
-				} else {
 				builder.Append(property.Name);
-				}
 				if (IncludeHtmlMarkup) {
 					builder.Append("</b>");
 				}
@@ -356,15 +364,13 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				builder.Append(' ');
 			}
 			
+			AppendTypeNameForFullyQualifiedMemberName(builder, e.DeclaringTypeReference);
+			
 			if (IncludeHtmlMarkup) {
 				builder.Append("<b>");
 			}
 			
-			if (UseFullyQualifiedMemberNames) {
-				builder.Append(e.FullyQualifiedName);
-			} else {
 			builder.Append(e.Name);
-			}
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</b>");
@@ -391,23 +397,17 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				builder.Append(' ');
 			}
 			
+			AppendTypeNameForFullyQualifiedMemberName(builder, m.DeclaringTypeReference);
+			
 			if (IncludeHtmlMarkup) {
 				builder.Append("<b>");
 			}
 			
-			if (m.IsConstructor) {
-				if (m.DeclaringType != null) {
+			if (m.IsConstructor && m.DeclaringType != null) {
 				builder.Append(m.DeclaringType.Name);
 			} else {
 				builder.Append(m.Name);
 			}
-			} else {
-				if (UseFullyQualifiedMemberNames) {
-					builder.Append(m.FullyQualifiedName);
-				} else {
-					builder.Append(m.Name);
-				}
-			}
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</b>");
@@ -454,6 +454,14 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 			return builder.ToString();
 		}
 		
+		void AppendTypeNameForFullyQualifiedMemberName(StringBuilder builder, IReturnType declaringType)
+		{
+			if (UseFullyQualifiedMemberNames && declaringType != null) {
+				AppendReturnType(builder, declaringType, true);
+				builder.Append('.');
+			}
+		}
+		
 		string ConvertTypeParameter(ITypeParameter tp)
 		{
 			if (tp.BoundTo != null)
@@ -479,24 +487,61 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 			
 			StringBuilder builder = new StringBuilder();
 			
+			AppendReturnType(builder, returnType, false);
+			
+			return builder.ToString();
+		}
+		
+		void AppendReturnType(StringBuilder builder, IReturnType returnType, bool forceFullyQualifiedName)
+		{
+			IReturnType arrayReturnType = returnType;
+			returnType = GetElementType(returnType);
+			
+			if (returnType == null)
+				return;
+			
 			string fullName = returnType.FullyQualifiedName;
 			string shortName;
-			if (fullName != null && TypeConversionTable.TryGetValue(fullName, out shortName)) {
+			bool isConstructedType = returnType.IsConstructedReturnType;
+			if (fullName != null && !isConstructedType && TypeConversionTable.TryGetValue(fullName, out shortName)) {
 				builder.Append(shortName);
 			} else {
-				if (UseFullyQualifiedTypeNames) {
+				IClass c = returnType.GetUnderlyingClass();
+				
+				if (c != null) {
+					IList<IReturnType> ta = isConstructedType ? returnType.CastToConstructedReturnType().TypeArguments : null;
+					AppendClassNameWithTypeParameters(builder, c, forceFullyQualifiedName || UseFullyQualifiedTypeNames, false, ta);
+				} else {
+					if (UseFullyQualifiedTypeNames || forceFullyQualifiedName) {
 						builder.Append(fullName);
 					} else {
 						builder.Append(returnType.Name);
 					}
+					if (isConstructedType) {
+						builder.Append('<');
+						IList<IReturnType> ta = returnType.CastToConstructedReturnType().TypeArguments;
+						for (int i = 0; i < ta.Count; ++i) {
+							if (i > 0) builder.Append(", ");
+							AppendReturnType(builder, ta[i], false);
+						}
+						builder.Append('>');
+					}
+				}
 			}
 			
-			UnpackNestedType(builder, returnType);
+			UnpackArrayType(builder, arrayReturnType);
+		}
 		
-			return builder.ToString();
+		static IReturnType GetElementType(IReturnType potentialArrayType)
+		{
+			ArrayReturnType result;
+			while ((result = potentialArrayType.CastToArrayReturnType()) != null) {
+				potentialArrayType = result.ArrayElementType;
+			}
+			return potentialArrayType;
 		}
 		
-		void UnpackNestedType(StringBuilder builder, IReturnType returnType)
+		static void UnpackArrayType(StringBuilder builder, IReturnType returnType)
 		{
 			if (returnType.IsArrayReturnType) {
 				builder.Append('[');
@@ -505,16 +550,7 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 					builder.Append(',');
 				}
 				builder.Append(']');
-				UnpackNestedType(builder, returnType.CastToArrayReturnType().ArrayElementType);
-			} else if (returnType.IsConstructedReturnType) {
-				UnpackNestedType(builder, returnType.CastToConstructedReturnType().UnboundType);
-				builder.Append('<');
-				IList<IReturnType> ta = returnType.CastToConstructedReturnType().TypeArguments;
-				for (int i = 0; i < ta.Count; ++i) {
-					if (i > 0) builder.Append(", ");
-					builder.Append(Convert(ta[i]));
-				}
-				builder.Append('>');
+				UnpackArrayType(builder, returnType.CastToArrayReturnType().ArrayElementType);
 			}
 		}
 		

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/CecilReader.cs

@@ -458,20 +458,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 			{
 				ModifierEnum m = ModifierEnum.None;
 				
-				if (method.IsStatic)
+				if (method.IsStatic) {
 					m |= ModifierEnum.Static;
-				
+				} else {
 					if (method.IsAbstract) {
 						m |= ModifierEnum.Abstract;
-				} else if (method.Overrides.Count > 0) {
-					if (method.IsFinal) {
+					} else if (method.IsFinal) {
 						m |= ModifierEnum.Sealed;
-					} else {
+					} else if (method.Overrides.Count > 0) {
 						m |= ModifierEnum.Override;
-					}
 					} else if (method.IsVirtual) {
 						m |= ModifierEnum.Virtual;
 					}
+				}
 				
 				if ((method.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
 					m |= ModifierEnum.Public;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/DomPersistence.cs

@@ -20,7 +20,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	{
 		public const long FileMagic = 0x11635233ED2F428C;
 		public const long IndexFileMagic = 0x11635233ED2F427D;
-		public const short FileVersion = 23;
+		public const short FileVersion = 24;
 		
 		ProjectContentRegistry registry;
 		string cacheDirectory;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/ReflectionEvent.cs

@@ -47,6 +47,14 @@ namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer
 				} else {
 					modifiers |= ModifierEnum.Internal;
 				}
+				
+				if (methodBase.IsFinal) {
+					modifiers |= ModifierEnum.Sealed;
+				} else if (methodBase.IsAbstract) {
+					modifiers |= ModifierEnum.Abstract;
+				} else if (methodBase.IsVirtual) {
+					modifiers |= ModifierEnum.Virtual;
+				}
 			} else {
 				// assume public property, if no methodBase could be get.
 				modifiers = ModifierEnum.Public;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/ReflectionMethod.cs

@@ -63,15 +63,14 @@ namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer
 				modifiers |= ModifierEnum.Internal;
 			}
 			
-			if (methodBase.IsVirtual) {
-				modifiers |= ModifierEnum.Virtual;
-			}
-			if (methodBase.IsAbstract) {
-				modifiers |= ModifierEnum.Abstract;
-			}
 			if (methodBase.IsFinal) {
 				modifiers |= ModifierEnum.Sealed;
+			} else if (methodBase.IsAbstract) {
+				modifiers |= ModifierEnum.Abstract;
+			} else if (methodBase.IsVirtual) {
+				modifiers |= ModifierEnum.Virtual;
 			}
+			
 			this.Modifiers = modifiers;
 			
 			ReflectionClass.AddAttributes(declaringType.ProjectContent, this.Attributes, CustomAttributeData.GetCustomAttributes(methodBase));

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/ReflectionProperty.cs

@@ -66,14 +66,12 @@ namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer
 					modifiers |= ModifierEnum.Internal;
 				}
 				
-				if (methodBase.IsVirtual) {
-					modifiers |= ModifierEnum.Virtual;
-				}
-				if (methodBase.IsAbstract) {
-					modifiers |= ModifierEnum.Abstract;
-				}
 				if (methodBase.IsFinal) {
 					modifiers |= ModifierEnum.Sealed;
+				} else if (methodBase.IsAbstract) {
+					modifiers |= ModifierEnum.Abstract;
+				} else if (methodBase.IsVirtual) {
+					modifiers |= ModifierEnum.Virtual;
 				}
 			} else { // assume public property, if no methodBase could be get.
 				modifiers = ModifierEnum.Public;

src/Main/ICSharpCode.SharpDevelop.Dom/Tests/ICSharpCode.SharpDevelop.Dom.Tests/CSharpAmbienceTests.cs

@@ -0,0 +1,52 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald"/>
+//     <version>$Revision$</version>
+// </file>
+
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.SharpDevelop.Dom.Tests
+{
+	[TestFixture]
+	public class CSharpAmbienceTests
+	{
+		CSharpAmbience fullMemberNameAmbience;
+		IClass valueCollection;
+		
+		[TestFixtureSetUpAttribute]
+		public void FixtureSetUp()
+		{
+			valueCollection = SharedProjectContentRegistryForTests.Instance.Mscorlib.GetClass("System.Collections.Generic.Dictionary.ValueCollection", 2);
+			Assert.AreEqual(2, valueCollection.TypeParameters.Count);
+			Assert.AreEqual(2, valueCollection.DeclaringType.TypeParameters.Count);
+			
+			fullMemberNameAmbience = new CSharpAmbience();
+			fullMemberNameAmbience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
+		}
+		
+		[TestAttribute]
+		public void TestFullClassNameOfClassInsideGenericClass()
+		{
+			Assert.AreEqual("public sealed class System.Collections.Generic.Dictionary<TKey, TValue>.ValueCollection", fullMemberNameAmbience.Convert(valueCollection));
+		}
+		
+		[TestAttribute]
+		public void TestFullNameOfValueCollectionCountProperty()
+		{
+			IProperty count = valueCollection.Properties.Single(p => p.Name == "Count");
+			Assert.AreEqual("public sealed int System.Collections.Generic.Dictionary<TKey, TValue>.ValueCollection.Count", fullMemberNameAmbience.Convert(count));
+		}
+		
+		[TestAttribute]
+		public void TestFullNameOfValueCollectionCopyToMethod()
+		{
+			IMethod copyTo = valueCollection.Methods.Single(m => m.Name == "CopyTo");
+			Assert.AreEqual("public sealed void System.Collections.Generic.Dictionary<TKey, TValue>.ValueCollection.CopyTo(TValue[] array, int index)", fullMemberNameAmbience.Convert(copyTo));
+		}
+	}
+}

src/Main/ICSharpCode.SharpDevelop.Dom/Tests/ICSharpCode.SharpDevelop.Dom.Tests/CodeSnippetConverterTests.cs

@@ -12,6 +12,13 @@ using NUnit.Framework;
 
 namespace ICSharpCode.SharpDevelop.Dom.Tests
 {
+	static class SharedProjectContentRegistryForTests
+	{
+		public static readonly ProjectContentRegistry Instance = new ProjectContentRegistry();
+		
+		static SharedProjectContentRegistryForTests() {} // delay-initialize
+	}
+	
 	[TestFixture]
 	public class CodeSnippetConverterTests
 	{
@@ -21,10 +28,9 @@ namespace ICSharpCode.SharpDevelop.Dom.Tests
 		
 		public CodeSnippetConverterTests()
 		{
-			ProjectContentRegistry pcr = new ProjectContentRegistry();
 			referencedContents = new List<IProjectContent> {
-				pcr.Mscorlib,
-				pcr.GetProjectContentForReference("System", "System")
+				SharedProjectContentRegistryForTests.Instance.Mscorlib,
+				SharedProjectContentRegistryForTests.Instance.GetProjectContentForReference("System", "System")
 			};
 		}
 		

src/Main/ICSharpCode.SharpDevelop.Dom/Tests/ICSharpCode.SharpDevelop.Dom.Tests/ICSharpCode.SharpDevelop.Dom.Tests.csproj

@@ -40,12 +40,16 @@
       <HintPath>..\..\..\..\Tools\NUnit\nunit.framework.dll</HintPath>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="ClassInheritanceTreeTests.cs" />
     <Compile Include="CodeSnippetConverterTests.cs" />
+    <Compile Include="CSharpAmbienceTests.cs" />
     <Compile Include="NRefactoryAstConverterTests.cs" />
     <Compile Include="NRefactoryRefactoringProviderTests.cs" />
     <Compile Include="NUnitHelpers\SyntaxHelpers.cs" />

src/Main/ICSharpCode.SharpDevelop.Dom/Tests/ICSharpCode.SharpDevelop.Dom.Tests/NRefactoryAstConverterTests.cs

@@ -16,13 +16,11 @@ namespace ICSharpCode.SharpDevelop.Dom.Tests
 	[TestFixture]
 	public class NRefactoryAstConverterTests
 	{
-		readonly ProjectContentRegistry projectContentRegistry = new ProjectContentRegistry();
-		
 		ICompilationUnit Parse(string code, SupportedLanguage language, bool referenceMscorlib)
 		{
 			DefaultProjectContent pc = new DefaultProjectContent();
 			if (referenceMscorlib) {
-				pc.AddReferencedContent(projectContentRegistry.Mscorlib);
+				pc.AddReferencedContent(SharedProjectContentRegistryForTests.Instance.Mscorlib);
 			}
 			NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
 			using (IParser p = ParserFactory.CreateParser(language, new StringReader(code))) {