Port debugger libraries to use new NRefactory.

Debugger/Debugger.Core/Debugger.Core.csproj

@@ -19,7 +19,7 @@
     <FileAlignment>4096</FileAlignment>
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
-    <OutputPath>\bin</OutputPath>
+    <OutputPath>bin\Debug\</OutputPath>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
     <PublishUrl>http://localhost/Debugger.Core/</PublishUrl>
     <Install>true</Install>

Debugger/Debugger.Core/NRefactory/Ast/ExpressionExtensionMethods.cs

@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Reflection;
 
 using Debugger;
@@ -149,9 +151,13 @@ namespace ICSharpCode.NRefactory.Ast
 		public static string PrettyPrint(this AstNode code)
 		{
 			if (code == null) return string.Empty;
-			CSharpOutputVisitor csOutVisitor = new CSharpOutputVisitor();
+
+			using (var sw = new StringWriter())
+			{
+				OutputVisitor csOutVisitor = new OutputVisitor(sw, new CSharpFormattingPolicy());
 				code.AcceptVisitor(csOutVisitor, null);
-			return csOutVisitor.Text;
+				return sw.ToString();
+			}
 		}
 		
 		public static AstType GetTypeReference(this Type type)
@@ -190,12 +196,21 @@ namespace ICSharpCode.NRefactory.Ast
 			
 			if (type.DeclaringType != null) {
 				var outterRef = type.DeclaringType.GetTypeReference();
-				var innerRef = new InnerClassTypeReference(outterRef, name, genTypeRefs);
-				innerRef.PointerNestingLevel = pointerNest;
-				innerRef.RankSpecifier = arrayRanks.ToArray();
+				var innerRef = new ComposedType() {
+					PointerRank = pointerNest,
+					ArraySpecifiers = arrayRanks.ConvertAll(r => new ArraySpecifier(r)),
+					BaseType = new MemberType() {
+						Target = outterRef, MemberName = name, TypeArguments = genTypeRefs }
+				};
+				
 				return innerRef.SetStaticType((DebugType)type);
 			} else {
-				return new TypeReference(name, pointerNest, arrayRanks.ToArray(), genTypeRefs).SetStaticType((DebugType)type);
+				return (new ComposedType() {
+				        	PointerRank = pointerNest,
+				        	ArraySpecifiers = arrayRanks.ConvertAll(r => new ArraySpecifier(r)),
+				        	BaseType = new SimpleType() {
+				        		Identifier = name,
+				        		TypeArguments = genTypeRefs }}).SetStaticType((DebugType)type);
 			}
 		}
 		
@@ -204,7 +219,7 @@ namespace ICSharpCode.NRefactory.Ast
 		/// Dotted names are split into separate nodes.
 		/// It does not normalize generic arguments.
 		/// </summary>
-		static SimpleType NormalizeTypeReference(this AstNode expr)
+		static AstType NormalizeTypeReference(this AstNode expr)
 		{
 			if (expr is IdentifierExpression) {
 				return new SimpleType() {
@@ -212,53 +227,67 @@ namespace ICSharpCode.NRefactory.Ast
 					TypeArguments = ((IdentifierExpression)expr).TypeArguments};
 			} else if (expr is MemberReferenceExpression) {
 				var outter = NormalizeTypeReference(((MemberReferenceExpression)expr).Target);
-				return new InnerClassTypeReference(
-					outter,
-					((MemberReferenceExpression)expr).MemberName,
-					((MemberReferenceExpression)expr).TypeArguments
-				);
+				return new MemberType() { Target = outter,
+					MemberName = ((MemberReferenceExpression)expr).MemberName,
+					TypeArguments = ((MemberReferenceExpression)expr).TypeArguments };
 			} else if (expr is TypeReferenceExpression) {
-				return NormalizeTypeReference(((TypeReferenceExpression)expr).TypeReference);
-			} else if (expr is InnerClassTypeReference) { // Frist - it is also TypeReference
-				InnerClassTypeReference typeRef = (InnerClassTypeReference)expr;
-				string[] names = typeRef.Type.Split('.');
-				var newRef = NormalizeTypeReference(typeRef.BaseType);
+				return NormalizeTypeReference(((TypeReferenceExpression)expr).Type);
+			} else if (expr is ComposedType) { // Frist - it is also TypeReference
+				var typeRef = (ComposedType)expr;
+				string[] names = null;
+				if (typeRef.BaseType is SimpleType)
+					names = (((SimpleType)typeRef.BaseType)).Identifier.Split('.');
+				else
+					names = (((MemberType)typeRef.BaseType)).MemberName.Split('.');
+				
+				var newRef = NormalizeTypeReference(typeRef.BaseType) as ComposedType;
 				foreach(string name in names) {
-					newRef = new InnerClassTypeReference(newRef, name, new List<TypeReference>());
+					newRef = new ComposedType() {
+						BaseType = new SimpleType() { Identifier = name, TypeArguments = new List<AstType>() }
+					};
 				}
-				newRef.GenericTypes.AddRange(typeRef.GenericTypes);
-				newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
-				newRef.RankSpecifier = typeRef.RankSpecifier;
+				//(((MemberType)newRef).TypeArguments as List<AstType>).AddRange(typeRef.TypeArguments);
+				newRef.PointerRank = typeRef.PointerRank;
+				newRef.ArraySpecifiers = typeRef.ArraySpecifiers;
 				return newRef;
-			} else if (expr is TypeReference) {
-				var typeRef = (TypeReference)expr;
-				string[] names = typeRef.Type.Split('.');
-				if (names.Length == 1)
-					return typeRef;
-				TypeReference newRef = null;
-				foreach(string name in names) {
-					if (newRef == null) {
-						newRef = new TypeReference(name, new List<TypeReference>());
-					} else {
-						newRef = new TypeReference(newRef, name, new List<TypeReference>());
-					}
 			}
-				newRef.GenericTypes.AddRange(typeRef.GenericTypes);
-				newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
-				newRef.RankSpecifier = typeRef.RankSpecifier;
-				return newRef;
-			} else {
+//			else if (expr is SimpleType) {
+//				var typeRef = (SimpleType)expr;
+//				string[] names = typeRef.Identifier.Split('.');
+//				if (names.Length == 1)
+//					return typeRef;
+//				SimpleType newRef = null;
+//				foreach(string name in names) {
+//					if (newRef == null) {
+//						newRef = new SimpleType() { Identifier = name, TypeArguments = new List<AstType>() };
+//					} else {
+//						newRef = new MemberType() { Target = newRef, MemberName = name, TypeArguments = new List<AstType>() };
+//					}
+//				}
+//				((List<AstType>)newRef.TypeArguments).AddRange(typeRef.TypeArguments);
+//				newRef.PointerNestingLevel = typeRef.PointerNestingLevel;
+//				newRef.RankSpecifier = typeRef.RankSpecifier;
+//				return newRef;
+//			}
+			else {
 				throw new EvaluateException(expr, "Type expected. {0} seen.", expr.GetType().FullName);
 			}
 		}
 		
-		static string GetNameWithArgCounts(SimpleType typeRef)
+		static string GetNameWithArgCounts(AstType typeRef)
 		{
-			string name = typeRef.Type;
-			if (typeRef.GenericTypes.Count > 0)
-				name += "`" + typeRef.GenericTypes.Count.ToString();
-			if (typeRef is InnerClassTypeReference) {
-				return GetNameWithArgCounts(((InnerClassTypeReference)typeRef).BaseType) + "." + name;
+			string name = string.Empty;
+			
+			if (typeRef is SimpleType)
+			{
+				name = ((SimpleType)typeRef).Identifier;
+				if (((SimpleType)typeRef).TypeArguments.Count() > 0)
+					name += "`" + ((SimpleType)typeRef).TypeArguments.Count().ToString();
+			}
+			
+			if (typeRef is MemberType) {
+				name = ((MemberType)typeRef).MemberName;
+				return GetNameWithArgCounts(((MemberType)typeRef).Target) + "." + name;
 			} else {
 				return name;
 			}
@@ -266,24 +295,26 @@ namespace ICSharpCode.NRefactory.Ast
 		
 		public static DebugType ResolveType(this AstNode expr, Debugger.AppDomain appDomain)
 		{
-			if (expr is TypeReference && expr.GetStaticType() != null)
+			if (expr is AstType && expr.GetStaticType() != null)
 				return expr.GetStaticType();
-			if (expr is TypeReferenceExpression && ((TypeReferenceExpression)expr).TypeReference.GetStaticType() != null)
-				return ((TypeReferenceExpression)expr).TypeReference.GetStaticType();
+			if (expr is TypeReferenceExpression && ((TypeReferenceExpression)expr).Type.GetStaticType() != null)
+				return ((TypeReferenceExpression)expr).Type.GetStaticType();
 			
 			appDomain.Process.TraceMessage("Resolving {0}", expr.PrettyPrint());
 			
-			TypeReference typeRef = NormalizeTypeReference(expr);
+			var typeRef = NormalizeTypeReference(expr);
 			
-			List<TypeReference> genTypeRefs;
-			if (typeRef is InnerClassTypeReference) {
-				genTypeRefs = ((InnerClassTypeReference)typeRef).CombineToNormalTypeReference().GenericTypes;
+			List<AstType> genTypeRefs = null;
+			if (typeRef is MemberType) {
+				//FIXME genTypeRefs = ((MemberType)typeRef).CombineToNormalTypeReference().TypeArguments as List<AstType>;
 			} else {
-				genTypeRefs = typeRef.GenericTypes;
+				if (typeRef is SimpleType) {
+					genTypeRefs = ((SimpleType)typeRef).TypeArguments as List<AstType>;
+				}
 			}
 			
 			List<DebugType> genArgs = new List<DebugType>();
-			foreach(TypeReference genTypeRef in genTypeRefs) {
+			foreach(var genTypeRef in genTypeRefs) {
 				genArgs.Add(ResolveType(genTypeRef, appDomain));
 			}
 			
@@ -294,37 +325,46 @@ namespace ICSharpCode.NRefactory.Ast
 		/// For performance this is separate method.
 		/// 'genArgs' should hold type for each generic parameter in 'typeRef'.
 		/// </summary>
-		static DebugType ResolveTypeInternal(SimpleType typeRef, DebugType[] genArgs, Debugger.AppDomain appDomain)
+		static DebugType ResolveTypeInternal(AstType typeRef, DebugType[] genArgs, Debugger.AppDomain appDomain)
 		{
 			DebugType type = null;
 			
+			if (typeRef is SimpleType) {
 				// Try to construct non-nested type
 				// If there are generic types up in the tree, it must be nested type
-			if (genArgs.Length == typeRef.GenericTypes.Count) {
-				string name = GetNameWithArgCounts(typeRef);
+				var simple = (SimpleType)typeRef;
+				
+				if (genArgs.Length == simple.TypeArguments.Count()) {
+					string name = GetNameWithArgCounts(simple);
 					type = DebugType.CreateFromNameOrNull(appDomain, name, null, genArgs);
 				}
-			
+			}
 			// Try to construct nested type
-			if (type == null && typeRef is InnerClassTypeReference) {
+			if (type == null && typeRef is MemberType) {
+				var member = (MemberType)typeRef;
 				DebugType[] outterGenArgs = genArgs;
 				// Do not pass our generic arguments to outter type
-				Array.Resize(ref outterGenArgs, genArgs.Length - typeRef.GenericTypes.Count);
+				Array.Resize(ref outterGenArgs, genArgs.Length - member.TypeArguments.Count());
 				
-				DebugType outter = ResolveTypeInternal(((InnerClassTypeReference)typeRef).BaseType, outterGenArgs, appDomain);
-				string nestedName = typeRef.GenericTypes.Count == 0 ? typeRef.Type : typeRef.Type + "`" + typeRef.GenericTypes.Count;
+				DebugType outter = ResolveTypeInternal(member.Target, outterGenArgs, appDomain);
+				string nestedName = member.TypeArguments.Count() == 0 ?
+					member.MemberName : member.MemberName + "`" + member.TypeArguments.Count();
 				type = DebugType.CreateFromNameOrNull(appDomain, nestedName, outter, genArgs);
 			}
 			
 			if (type == null)
 				throw new GetValueException("Can not resolve " + typeRef.PrettyPrint());
 			
-			for(int i = 0; i < typeRef.PointerNestingLevel; i++) {
+			if (typeRef is ComposedType) {
+				
+				for(int i = 0; i < ((ComposedType)typeRef).PointerRank; i++) {
 					type = (DebugType)type.MakePointerType();
 				}
-			if (typeRef.RankSpecifier != null) {
-				for(int i = typeRef.RankSpecifier.Length - 1; i >= 0; i--) {
-					type = (DebugType)type.MakeArrayType(typeRef.RankSpecifier[i] + 1);
+				if (((ComposedType)typeRef).ArraySpecifiers != null) {
+					var enumerator = ((ComposedType)typeRef).ArraySpecifiers.Reverse().GetEnumerator();
+						while (enumerator.MoveNext()) {
+						type = (DebugType)type.MakeArrayType(enumerator.Current.Dimensions + 1);
+					}
 				}
 			}
 			return type;

Debugger/Debugger.Core/NRefactory/Visitors/ExpressionEvaluator.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -60,16 +61,22 @@ namespace ICSharpCode.NRefactory.Visitors
 		
 		public static AstNode Parse(string code, SupportedLanguage language)
 		{
-			SnippetParser parser = new SnippetParser(language);
-			AstNode astRoot = parser.Parse(code);
-			if (parser.Errors.Count > 0) {
-				throw new GetValueException(parser.Errors.ErrorOutput);
-			}
-			if (parser.SnippetType != SnippetType.Expression && parser.SnippetType != SnippetType.Statements) {
-				throw new GetValueException("Code must be expression or statement");
+			switch (language) {
+				case SupportedLanguage.CSharp:
+					var parser = new CSharpParser();
+					using (var textReader = new StringReader(code)) {
+						AstNode astRoot = parser.ParseExpression(textReader);
+						if (parser.HasErrors) {
+							throw new GetValueException("Parser errors");
 						}
+
 						return astRoot;
 					}
+					break;
+				default:
+					throw new ArgumentException("Unsuported language");
+			}
+		}
 		
 		/// <summary> Evaluate given expression.  If you have expression tree already, use overloads of this method.</summary>
 		/// <returns> Returned value or null for statements </returns>
@@ -106,16 +113,20 @@ namespace ICSharpCode.NRefactory.Visitors
 		/// </summary>
 		public static Expression ParseExpression(string code, SupportedLanguage language)
 		{
-			SnippetParser parser = new SnippetParser(language);
-			AstNode astRoot = parser.Parse(code);
-			if (parser.Errors.Count > 0) {
-				throw new GetValueException(parser.Errors.ErrorOutput);
+			switch (language) {
+				case SupportedLanguage.CSharp:
+					var parser = new CSharpParser();
+					using (var textReader = new StringReader(code)) {
+						AstNode astRoot = parser.ParseExpression(textReader);
+						if (parser.HasErrors) {
+							throw new GetValueException("Parser errors");
+						}
+
+						return astRoot as Expression;
 					}
-			Expression astExpression = astRoot as Expression;
-			if (astExpression == null) {
-				throw new GetValueException("Code must be expression");
+				default:
+					throw new ArgumentException("Unsuported language");
 			}
-			return astExpression;
 		}
 		
 		public static string FormatValue(Value val)
@@ -279,20 +290,16 @@ namespace ICSharpCode.NRefactory.Visitors
 		{
 			BinaryOperatorType op;
 			switch (assignmentExpression.Operator) {
-				//case AssignmentOperatorType.Assign:        op = BinaryOperatorType.None; break;
 					case AssignmentOperatorType.Add:           op = BinaryOperatorType.Add; break;
-				//case AssignmentOperatorType.ConcatString:  op = BinaryOperatorType.Concat; break;
 					case AssignmentOperatorType.Subtract:      op = BinaryOperatorType.Subtract; break;
 					case AssignmentOperatorType.Multiply:      op = BinaryOperatorType.Multiply; break;
 					case AssignmentOperatorType.Divide:        op = BinaryOperatorType.Divide; break;
-				//case AssignmentOperatorType.DivideInteger: op = BinaryOperatorType.DivideInteger; break;
 					case AssignmentOperatorType.ShiftLeft:     op = BinaryOperatorType.ShiftLeft; break;
 					case AssignmentOperatorType.ShiftRight:    op = BinaryOperatorType.ShiftRight; break;
 					case AssignmentOperatorType.ExclusiveOr:   op = BinaryOperatorType.ExclusiveOr; break;
 					case AssignmentOperatorType.Modulus:       op = BinaryOperatorType.Modulus; break;
 					case AssignmentOperatorType.BitwiseAnd:    op = BinaryOperatorType.BitwiseAnd; break;
 					case AssignmentOperatorType.BitwiseOr:     op = BinaryOperatorType.BitwiseOr; break;
-				//case AssignmentOperatorType.Power:         op = BinaryOperatorType.Power; break;
 					default: throw new GetValueException("Unknown operator " + assignmentExpression.Operator);
 			}
 			
@@ -343,7 +350,7 @@ namespace ICSharpCode.NRefactory.Visitors
 		public object VisitCastExpression(CastExpression castExpression, object data)
 		{
 			TypedValue val = Evaluate(castExpression.Expression);
-			DebugType castTo = castExpression.ResolveType(context.AppDomain).CastTo();
+			DebugType castTo = null;// FIXME castExpression.CastTo().ResolveType(context.AppDomain);
 			if (castTo.IsPrimitive && val.Type.IsPrimitive && castTo != val.Type) {
 				object oldVal = val.PrimitiveValue;
 				object newVal;
@@ -491,10 +498,10 @@ namespace ICSharpCode.NRefactory.Visitors
 		
 		public object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
 		{
-			if (arrayCreateExpression.Initializer.RankSpecifier[0] != 0)
+			if (arrayCreateExpression.AdditionalArraySpecifiers.Count() != 0)
 				throw new EvaluateException(arrayCreateExpression, "Multi-dimensional arrays are not suppored");
 			
-			DebugType type = arrayCreateExpression.CreateType.ResolveType(context.AppDomain);
+			DebugType type = arrayCreateExpression.Type.ResolveType(context.AppDomain);
 			int length = 0;
 			if (arrayCreateExpression.Arguments.Count() == 1) {
 				length = EvaluateAsInt(arrayCreateExpression.Arguments.First());
@@ -592,9 +599,9 @@ namespace ICSharpCode.NRefactory.Visitors
 				TypedValue newValue = null;
 				try {
 					if (op == UnaryOperatorType.Decrement || op == UnaryOperatorType.PostDecrement)
-						newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Subtract), null);
+						newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression() { Right = unaryOperatorExpression.Expression, Operator = AssignmentOperatorType.Subtract }, null);
 					if (op == UnaryOperatorType.Increment || op == UnaryOperatorType.PostIncrement)
-						newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression(unaryOperatorExpression.Expression, AssignmentOperatorType.Add), null);
+						newValue = (TypedValue)VisitAssignmentExpression(new AssignmentExpression(){ Right = unaryOperatorExpression.Expression, Operator = AssignmentOperatorType.Add }, null);
 				} catch (EvaluateException e) {
 					throw new EvaluateException(unaryOperatorExpression, e.Message);
 				}

Debugger/ILSpy.Debugger/AvalonEdit/IconBarMargin.cs

@@ -25,6 +25,7 @@ using System.Windows.Media;
 using ICSharpCode.AvalonEdit.Editing;
 using ICSharpCode.AvalonEdit.Rendering;
 using ICSharpCode.AvalonEdit.Utils;
+using ICSharpCode.Decompiler.Disassembler;
 using ILSpy.Debugger.Bookmarks;
 using ILSpy.Debugger.Services;
 using Mono.Cecil;

Debugger/ILSpy.Debugger/Bookmarks/BookmarkManager.cs

@@ -119,7 +119,7 @@ namespace ILSpy.Debugger.Bookmarks
 				}
 			}
 			// no bookmark at that line: create a new bookmark			
-			BookmarkManager.AddMark(bookmarkFactory(new AstLocation(0, line)));
+			BookmarkManager.AddMark(bookmarkFactory(new AstLocation(line, 0)));
 		}
 		
 		public static event BookmarkEventHandler Removed;

Debugger/ILSpy.Debugger/Models/TreeModel/ChildNodesOfObject.cs

@@ -97,11 +97,7 @@ namespace ILSpy.Debugger.Models.TreeModel
 		public static IEnumerable<TreeNode> LazyGetItemsOfIList(Expression targetObject)
 		{
 			// This is needed for expanding IEnumerable<T>
-			targetObject = new CastExpression(
-				new TypeReference(typeof(IList).FullName),
-				targetObject,
-				CastType.Cast
-			);
+			targetObject = new CastExpression() { Expression = targetObject, Type = new SimpleType() { Identifier = typeof(IList).FullName } };
 			int count = 0;
 			GetValueException error = null;
 			try {

Debugger/ILSpy.Debugger/Models/TreeModel/StackFrameNode.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using Debugger;
 using Debugger.MetaData;
 using ICSharpCode.NRefactory.Ast;
+using ICSharpCode.NRefactory.CSharp;
 
 namespace ILSpy.Debugger.Models.TreeModel
 {

Debugger/ILSpy.Debugger/Services/Debugger/DebuggerHelper.cs

@@ -27,8 +27,8 @@ namespace ILSpy.Debugger.Services.Debugger
 			listType = DebugType.CreateFromType(itemType.AppDomain, typeof(System.Collections.Generic.List<>), itemType);
 			var iEnumerableType = DebugType.CreateFromType(itemType.AppDomain, typeof(IEnumerable<>), itemType);
 			// explicitely cast the variable to IEnumerable<T>, where T is itemType
-			Expression iEnumerableVariableExplicitCast = new CastExpression(iEnumerableType.GetTypeReference() , iEnumerableVariable, CastType.Cast);
-			return new ObjectCreateExpression(listType.GetTypeReference(), iEnumerableVariableExplicitCast.ToList());
+			Expression iEnumerableVariableExplicitCast = new CastExpression { Expression = iEnumerableVariable , Type = iEnumerableType.GetTypeReference() };
+			return new ObjectCreateExpression() { Type = listType.GetTypeReference(), Arguments = iEnumerableVariableExplicitCast.ToList() };
 		}
 		
 		/// <summary>

NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Expressions/BinaryOperatorExpression.cs

@@ -167,6 +167,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		ShiftRight,
 		
 		/// <summary>left ?? right</summary>
-		NullCoalescing
+		NullCoalescing,
+		
+		None
 	}
 }