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

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

samples/NRefactoryDemo/MainForm.cs

@@ -108,7 +108,9 @@ namespace NRefactoryDemo
 		{
 			using (IParser parser = ParserFactory.CreateParser(language, new StringReader(text))) {
 				parser.Parse();
+				// this allows retrieving comments, preprocessor directives, etc. (stuff that isn't part of the syntax)
 				SetSpecials(parser.Lexer.SpecialTracker.RetrieveSpecials());
+				// this retrieves the root node of the result AST
 				astView.Unit = parser.CompilationUnit;
 				if (parser.Errors.Count > 0) {
 					MessageBox.Show(parser.Errors.ErrorOutput, "Parse errors");
@@ -128,6 +130,7 @@ namespace NRefactoryDemo
 		
 		void GenerateCode(IOutputAstVisitor outputVisitor)
 		{
+			// re-insert the comments we saved from the parser into the output
 			using (SpecialNodesInserter.Install(savedSpecialsList, outputVisitor)) {
 				astView.Unit.AcceptVisitor(outputVisitor, null);
 			}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/VBNet/VBNetAmbience.cs

@@ -133,28 +133,7 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 				builder.Append(' ');
 			}
 			
-			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("(Of ");
-				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("(");
@@ -202,6 +181,50 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 			return builder.ToString();
 		}
 		
+		void AppendTypeNameForFullyQualifiedMemberName(StringBuilder builder, IReturnType declaringType)
+		{
+			if (UseFullyQualifiedMemberNames && declaringType != null) {
+				AppendReturnType(builder, declaringType, true);
+				builder.Append('.');
+			}
+		}
+		
+		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("(Of ");
+				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)
 		{
 			if (c == null)
@@ -260,15 +283,16 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</i>");
-				builder.Append("<b>");
 			}
 			
-			if (UseFullyQualifiedMemberNames) {
-				builder.Append(field.FullyQualifiedName);
-			} else {
-				builder.Append(field.Name);
+			AppendTypeNameForFullyQualifiedMemberName(builder, field.DeclaringTypeReference);
+			
+			if (IncludeHtmlMarkup) {
+				builder.Append("<b>");
 			}
 			
+			builder.Append(field.Name);
+			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</b>");
 			}
@@ -308,15 +332,12 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 				builder.Append("Property ");
 			}
 			
+			AppendTypeNameForFullyQualifiedMemberName(builder, property.DeclaringTypeReference);
 			if (IncludeHtmlMarkup) {
 				builder.Append("<b>");
 			}
 			
-			if (UseFullyQualifiedMemberNames) {
-				builder.Append(property.FullyQualifiedName);
-			} else {
-				builder.Append(property.Name);
-			}
+			builder.Append(property.Name);
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</b>");
@@ -365,15 +386,13 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 				builder.Append("Event ");
 			}
 			
+			AppendTypeNameForFullyQualifiedMemberName(builder, e.DeclaringTypeReference);
+			
 			if (IncludeHtmlMarkup) {
 				builder.Append("<b>");
 			}
 			
-			if (UseFullyQualifiedMemberNames) {
-				builder.Append(e.FullyQualifiedName);
-			} else {
-				builder.Append(e.Name);
-			}
+			builder.Append(e.Name);
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</b>");
@@ -409,16 +428,13 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 				}
 			}
 
-			string dispName = UseFullyQualifiedMemberNames ? m.FullyQualifiedName : m.Name;
-			if (m.IsConstructor) {
-				dispName = "New";
-			}
+			AppendTypeNameForFullyQualifiedMemberName(builder, m.DeclaringTypeReference);
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("<b>");
 			}
 			
-			builder.Append(dispName);
+			builder.Append(m.IsConstructor ? "New" : m.Name);
 			
 			if (IncludeHtmlMarkup) {
 				builder.Append("</b>");
@@ -489,24 +505,61 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 			
 			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) {
-					builder.Append(fullName);
+				IClass c = returnType.GetUnderlyingClass();
+				
+				if (c != null) {
+					IList<IReturnType> ta = isConstructedType ? returnType.CastToConstructedReturnType().TypeArguments : null;
+					AppendClassNameWithTypeParameters(builder, c, forceFullyQualifiedName || UseFullyQualifiedTypeNames, false, ta);
 				} else {
-					builder.Append(returnType.Name);
+					if (UseFullyQualifiedTypeNames || forceFullyQualifiedName) {
+						builder.Append(fullName);
+					} else {
+						builder.Append(returnType.Name);
+					}
+					if (isConstructedType) {
+						builder.Append("(Of ");
+						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);
-			
-			return builder.ToString();
+			UnpackArrayType(builder, arrayReturnType);
+		}
+		
+		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('(');
@@ -515,16 +568,7 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 					builder.Append(',');
 				}
 				builder.Append(')');
-				UnpackNestedType(builder, returnType.CastToArrayReturnType().ArrayElementType);
-			} else if (returnType.IsConstructedReturnType) {
-				UnpackNestedType(builder, returnType.CastToConstructedReturnType().UnboundType);
-				builder.Append("(Of ");
-				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/Tests/ICSharpCode.SharpDevelop.Dom.Tests/ICSharpCode.SharpDevelop.Dom.Tests.csproj

@@ -55,6 +55,7 @@
     <Compile Include="NUnitHelpers\SyntaxHelpers.cs" />
     <Compile Include="NUnitHelpers\Constraints.cs" />
     <Compile Include="ProjectContentClassManagementTest.cs" />
+    <Compile Include="VBNetAmbienceTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\Libraries\NRefactory\Project\NRefactory.csproj">

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

@@ -0,0 +1,53 @@
+// <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.VBNet;
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.SharpDevelop.Dom.Tests
+{
+	[TestFixture]
+	public class VBNetAmbienceTests
+	{
+		VBNetAmbience 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 VBNetAmbience();
+			fullMemberNameAmbience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
+		}
+		
+		[TestAttribute]
+		public void TestFullClassNameOfClassInsideGenericClass()
+		{
+			Assert.AreEqual("Public NotInheritable Class System.Collections.Generic.Dictionary(Of TKey, TValue).ValueCollection", fullMemberNameAmbience.Convert(valueCollection));
+		}
+		
+		[TestAttribute]
+		public void TestFullNameOfValueCollectionCountProperty()
+		{
+			IProperty count = valueCollection.Properties.Single(p => p.Name == "Count");
+			Assert.AreEqual("Public NotOverridable ReadOnly Property System.Collections.Generic.Dictionary(Of TKey, TValue).ValueCollection.Count As Integer", fullMemberNameAmbience.Convert(count));
+		}
+		
+		[TestAttribute]
+		public void TestFullNameOfValueCollectionCopyToMethod()
+		{
+			IMethod copyTo = valueCollection.Methods.Single(m => m.Name == "CopyTo");
+			Assert.AreEqual("Public NotOverridable Sub System.Collections.Generic.Dictionary(Of TKey, TValue).ValueCollection.CopyTo(array As TValue(), index As Integer)", fullMemberNameAmbience.Convert(copyTo));
+		}
+	}
+}