Rename ExpressionNode to ValueNode to emphasise that the node is immutable. The expression is now evaluated before the node's constructor.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@2845 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Debugger.AddIn.csproj

@@ -71,7 +71,7 @@
     <Compile Include="Src\TreeModel\Adapters\DynamicTreeDebuggerRow.cs" />
     <Compile Include="Src\TreeModel\Adapters\TreeViewNode.cs" />
     <Compile Include="Src\TreeModel\ArrayRangeNode.cs" />
-    <Compile Include="Src\TreeModel\ExpressionNode.cs" />
+    <Compile Include="Src\TreeModel\ValueNode.cs" />
     <Compile Include="Src\TreeModel\IContextMenu.cs" />
     <Compile Include="Src\TreeModel\ISetText.cs" />
     <Compile Include="Src\TreeModel\ChildNodesOfObject.cs" />

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/WindowsDebugger.cs

@@ -249,15 +249,14 @@ namespace ICSharpCode.SharpDevelop.Services
 		/// Gets variable of given name.
 		/// Returns null if unsuccessful.
 		/// </summary>
-		public Expression GetExpressionFromName(string variableName)
+		public Value GetValueFromName(string variableName)
 		{
 			if (debuggedProcess == null || debuggedProcess.IsRunning || debuggedProcess.SelectedStackFrame == null) { 
 				return null;
 			} else {
 				Expression expression = Debugger.Expressions.SimpleParser.Parse(variableName);
 				try {
-					expression.Evaluate(debuggedProcess.SelectedStackFrame);
-					return expression;
+					return expression.Evaluate(debuggedProcess.SelectedStackFrame);
 				} catch (GetValueException) {
 					return null;
 				}
@@ -271,12 +270,12 @@ namespace ICSharpCode.SharpDevelop.Services
 		/// </summary>
 		public string GetValueAsString(string variableName)
 		{
-			Expression expression = GetExpressionFromName(variableName);
+			Value val = GetValueFromName(variableName);
 			
-			if (expression == null) {
+			if (val == null) {
 				return null;
 			} else {
-				return expression.Evaluate(this.DebuggedProcess.SelectedStackFrame).AsString;
+				return val.AsString;
 			}
 		}
 		
@@ -286,13 +285,13 @@ namespace ICSharpCode.SharpDevelop.Services
 		/// </summary>
 		public DebuggerGridControl GetTooltipControl(string variableName)
 		{
-			Expression expression = GetExpressionFromName(variableName);
+			Value val = GetValueFromName(variableName);
 			
-			if (expression == null) {
+			if (val == null) {
 				return null;
 			} else {
 				try {
-					return new DebuggerGridControl(new DynamicTreeDebuggerRow(DebuggedProcess, new ExpressionNode(expression)));
+					return new DebuggerGridControl(new DynamicTreeDebuggerRow(DebuggedProcess, new ValueNode(val)));
 				} catch (AbortedBecauseDebugeeStateExpiredException) {
 					return null;
 				}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/TreeModel/ArrayRangeNode.cs

@@ -20,7 +20,7 @@ namespace Debugger.AddIn.TreeModel
 		public static IEnumerable<AbstractNode> GetChildNodesOfArray(Expression expression, ArrayDimensions dimensions)
 		{
 			foreach(Expression childExpr in expression.AppendIndexers(dimensions)) {
-				yield return new ExpressionNode(childExpr);
+				yield return Util.CreateNode(childExpr);
 			}
 		}
 	}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/TreeModel/ChildNodesOfObject.cs

@@ -17,48 +17,48 @@ namespace Debugger.AddIn.TreeModel
 {
 	public partial class Util
 	{
-		public static IEnumerable<AbstractNode> GetChildNodesOfObject(Expression expression, DebugType shownType)
+		public static IEnumerable<AbstractNode> GetChildNodesOfObject(Expression targetObject, DebugType shownType)
 		{
 			if (shownType.BaseType != null) {
-				yield return new BaseClassNode(expression, shownType.BaseType);
+				yield return new BaseClassNode(targetObject, shownType.BaseType);
 			}
 			if (shownType.HasMembers(BindingFlags.NonPublicInstance)) {
-				yield return new NonPublicInstanceMembersNode(expression, shownType);
+				yield return new NonPublicInstanceMembersNode(targetObject, shownType);
 			}
 			if (shownType.HasMembers(BindingFlags.Static)) {
-				yield return new StaticMembersNode(expression, shownType);
+				yield return new StaticMembersNode(targetObject, shownType);
 			}
-			foreach(Expression childExpr in expression.AppendObjectMembers(shownType, BindingFlags.PublicInstance)) {
-				yield return new ExpressionNode(childExpr);
+			foreach(Expression childExpr in targetObject.AppendObjectMembers(shownType, BindingFlags.PublicInstance)) {
+				yield return Util.CreateNode(childExpr);
 			}
 		}
 	}
 	
 	public class BaseClassNode: AbstractNode
 	{
-		Expression expression;
+		Expression targetObject;
 		DebugType shownType;
 		
-		public BaseClassNode(Expression expression, DebugType shownType)
+		public BaseClassNode(Expression targetObject, DebugType shownType)
 		{
-			this.expression = expression;
+			this.targetObject = targetObject;
 			this.shownType = shownType;
 			
 			this.Image = DebuggerIcons.ImageList.Images[0]; // Class
 			this.Name = StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.BaseClass}");
 			this.Type = shownType.FullName;
-			this.ChildNodes = Util.GetChildNodesOfObject(expression, shownType);
+			this.ChildNodes = Util.GetChildNodesOfObject(targetObject, shownType);
 		}
 	}
 	
 	public class NonPublicInstanceMembersNode: AbstractNode
 	{
-		Expression expression;
+		Expression targetObject;
 		DebugType shownType;
 		
-		public NonPublicInstanceMembersNode(Expression expression, DebugType shownType)
+		public NonPublicInstanceMembersNode(Expression targetObject, DebugType shownType)
 		{
-			this.expression = expression;
+			this.targetObject = targetObject;
 			this.shownType = shownType;
 			
 			this.Name = StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.PrivateMembers}");
@@ -67,20 +67,20 @@ namespace Debugger.AddIn.TreeModel
 		
 		IEnumerable<AbstractNode> GetChildNodes()
 		{
-			foreach(Expression childExpr in expression.AppendObjectMembers(shownType, BindingFlags.NonPublicInstance)) {
-				yield return new ExpressionNode(childExpr);
+			foreach(Expression childExpr in targetObject.AppendObjectMembers(shownType, BindingFlags.NonPublicInstance)) {
+				yield return Util.CreateNode(childExpr);
 			}
 		}
 	}
 	
 	public class StaticMembersNode: AbstractNode
 	{
-		Expression expression;
+		Expression targetObject;
 		DebugType shownType;
 		
-		public StaticMembersNode(Expression expression, DebugType shownType)
+		public StaticMembersNode(Expression targetObject, DebugType shownType)
 		{
-			this.expression = expression;
+			this.targetObject = targetObject;
 			this.shownType = shownType;
 			
 			this.Name = StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.StaticMembers}");
@@ -90,22 +90,22 @@ namespace Debugger.AddIn.TreeModel
 		IEnumerable<AbstractNode> GetChildNodes()
 		{
 			if (shownType.HasMembers(BindingFlags.NonPublicStatic)) {
-				yield return new NonPublicStaticMembersNode(expression, shownType);
+				yield return new NonPublicStaticMembersNode(targetObject, shownType);
 			}
-			foreach(Expression childExpr in expression.AppendObjectMembers(shownType, BindingFlags.PublicStatic)) {
-				yield return new ExpressionNode(childExpr);
+			foreach(Expression childExpr in targetObject.AppendObjectMembers(shownType, BindingFlags.PublicStatic)) {
+				yield return Util.CreateNode(childExpr);
 			}
 		}
 	}
 	
 	public class NonPublicStaticMembersNode: AbstractNode
 	{
-		Expression expression;
+		Expression targetObject;
 		DebugType shownType;
 		
-		public NonPublicStaticMembersNode(Expression expression, DebugType shownType)
+		public NonPublicStaticMembersNode(Expression targetObject, DebugType shownType)
 		{
-			this.expression = expression;
+			this.targetObject = targetObject;
 			this.shownType = shownType;
 			
 			this.Name = StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.PrivateStaticMembers}");
@@ -114,8 +114,8 @@ namespace Debugger.AddIn.TreeModel
 		
 		IEnumerable<AbstractNode> GetChildNodes()
 		{
-			foreach(Expression childExpr in expression.AppendObjectMembers(shownType, BindingFlags.NonPublicStatic)) {
-				yield return new ExpressionNode(childExpr);
+			foreach(Expression childExpr in targetObject.AppendObjectMembers(shownType, BindingFlags.NonPublicStatic)) {
+				yield return Util.CreateNode(childExpr);
 			}
 		}
 	}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/TreeModel/StackFrameNode.cs

@@ -32,7 +32,7 @@ namespace Debugger.AddIn.TreeModel
 		IEnumerable<AbstractNode> GetChildNodes()
 		{
 			foreach(Expression expr in Expression.MethodVariables(stackFrame.MethodInfo)) {
-				yield return new ExpressionNode(expr);
+				yield return Util.CreateNode(expr);
 			}
 		}
 	}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/TreeModel/Util.cs

@@ -8,6 +8,10 @@ using System;
 using System.Windows.Forms;
 
 using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Debugging;
+using ICSharpCode.SharpDevelop.Services;
+
+using Debugger.Expressions;
 
 namespace Debugger.AddIn.TreeModel
 {
@@ -34,6 +38,17 @@ namespace Debugger.AddIn.TreeModel
 				// LoggingService.InfoFormatted("Rendering: {0} ms => work budget: {1} ms ({2:f1} FPS)", doEventsDuration, workTime, fps);
 			}
 		}
+		
+		public static AbstractNode CreateNode(Expression expression)
+		{
+			return new ValueNode(expression.Evaluate(WindowsDebugger.DebuggedProcess.SelectedStackFrame));
+		}
+		
+		public static WindowsDebugger WindowsDebugger {
+			get {
+				return (WindowsDebugger)DebuggerService.CurrentDebugger;
+			}
+		}
 	}
 	
 	public class AbortedBecauseDebugeeStateExpiredException: System.Exception

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/TreeModel/ValueNode.cs

@@ -18,7 +18,7 @@ using Debugger.Expressions;
 
 namespace Debugger.AddIn.TreeModel
 {
-	public class ExpressionNode: AbstractNode, ISetText, IContextMenu
+	public class ValueNode: AbstractNode, ISetText, IContextMenu
 	{
 		Expression expression;
 		
@@ -26,11 +26,9 @@ namespace Debugger.AddIn.TreeModel
 			get { return expression; }
 		}
 		
-		public ExpressionNode(Expression expression)
+		public ValueNode(Value val)
 		{
-			this.expression = expression;
-			
-			Value val = expression.Evaluate(WindowsDebugger.DebuggedProcess.SelectedStackFrame);
+			this.expression = val.Expression;
 			
 			if (val.IsObject) {
 				this.Image = DebuggerIcons.ImageList.Images[0]; // Class