If object supports IList, use it to access the items from local variables pad.

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

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

@@ -72,6 +72,7 @@
     <Compile Include="Src\TreeModel\Adapters\TreeViewNode.cs" />
     <Compile Include="Src\TreeModel\ArrayRangeNode.cs" />
     <Compile Include="Src\TreeModel\ErrorNode.cs" />
+    <Compile Include="Src\TreeModel\Extensions\IList.cs" />
     <Compile Include="Src\TreeModel\ValueNode.cs" />
     <Compile Include="Src\TreeModel\IContextMenu.cs" />
     <Compile Include="Src\TreeModel\ISetText.cs" />
@@ -127,6 +128,7 @@
     <Folder Include="Src\Expressions" />
     <Folder Include="Src\TreeModel" />
     <Folder Include="Src\TreeModel\Adapters" />
+    <Folder Include="Src\TreeModel\Extensions" />
     <ProjectReference Include="..\..\..\..\..\Libraries\NRefactory\Project\NRefactory.csproj">
       <Project>{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}</Project>
       <Name>NRefactory</Name>

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

@@ -32,6 +32,10 @@ namespace Debugger.AddIn.TreeModel
 			{
 				yield return new StaticMembersNode(targetObject, shownType);
 			}
+			DebugType iListType = shownType.GetInterface(typeof(IList).FullName);
+			if (iListType != null) {
+				yield return new IListNode(targetObject, iListType);
+			}
 			foreach(Expression childExpr in targetObject.AppendObjectMembers(shownType, Flags)) {
 				yield return ValueNode.Create(childExpr);
 			}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/TreeModel/Extensions/IList.cs

@@ -0,0 +1,50 @@
+// <file>
+//     <copyright license="BSD-new" see="prj:///COPYING"/>
+//     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Drawing;
+
+using Debugger.Expressions;
+using Debugger.MetaData;
+
+namespace Debugger.AddIn.TreeModel
+{
+	public class IListNode: AbstractNode
+	{
+		Expression targetObject;
+		DebugType iListType;
+		
+		public IListNode(Expression targetObject, DebugType iListType)
+		{
+			this.targetObject = targetObject;
+			this.iListType = iListType;
+			
+			this.Name = "IList";
+			this.ChildNodes = GetChildNodes();
+		}
+		
+		IEnumerable<AbstractNode> GetChildNodes()
+		{
+			PropertyInfo countProperty = iListType.GetInterface(typeof(ICollection).FullName).GetProperty("Count");
+			Expression countExpr = targetObject.AppendPropertyReference(countProperty);
+			AbstractNode countNode = ValueNode.Create(countExpr);
+			int count = 0;
+			if (countNode is ValueNode) {
+				count = int.Parse(countNode.Text);
+			} else {
+				yield return countNode;
+			}
+			
+			for(int i = 0; i < count; i++) {
+				PropertyInfo itemProperty = iListType.GetProperty("Item");
+				Expression itemExpr = targetObject.AppendMemberReference(itemProperty, new PrimitiveExpression(i));
+				yield return ValueNode.Create(itemExpr);
+			}
+		}
+	}
+}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Control/Eval.cs

@@ -82,7 +82,7 @@ namespace Debugger
 			this.state = EvalState.Evaluating;
 		}
 		
-		static Eval CreateEval(Process process, string description, EvalStarter evalStarter)
+		static ICorDebugEval CreateCorEval(Process process)
 		{
 			process.AssertPaused();
 			
@@ -98,7 +98,12 @@ namespace Debugger
 				throw new GetValueException("Can not evaluate because thread is not at a safe point");
 			}
 			
-			ICorDebugEval corEval = targetThread.CorThread.CreateEval();
+			return targetThread.CorThread.CreateEval();
+		}
+		
+		static Eval CreateEval(Process process, string description, EvalStarter evalStarter)
+		{
+			ICorDebugEval corEval = CreateCorEval(process);
 			
 			Eval newEval = new Eval(process, description, corEval);
 			
@@ -227,6 +232,28 @@ namespace Debugger
 			);
 		}
 		
+		public static Value CreateValue(Process process, object value)
+		{
+			CorElementType corElemType; 
+			if (value is int) {
+				corElemType = CorElementType.I4;
+			} else {
+				throw new NotImplementedException();
+			}
+			ICorDebugEval corEval = CreateCorEval(process);
+			ICorDebugValue corValue = corEval.CreateValue((uint)corElemType, null);
+			Value v = new Value(process, new Expressions.PrimitiveExpression(value), corValue);
+			v.PrimitiveValue = value;
+			return v;
+		}
+		
+		public static Value CreateValueForType(Process process, DebugType debugType)
+		{
+			ICorDebugEval corEval = CreateCorEval(process);
+			ICorDebugValue corValue = corEval.CastTo<ICorDebugEval2>().CreateValueForType(debugType.CorType);
+			return new Value(process, corValue);
+		}
+		
 		#region Convenience methods
 		
 		public static Value NewString(Process process, string textToCreate)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Expressions/Ast/MemberReferenceExpression.cs

@@ -35,7 +35,7 @@ namespace Debugger.Expressions
 			get { return arguments; }
 		}
 		
-		public MemberReferenceExpression(Expression targetObject, MemberInfo memberInfo, Expression[] arguments)
+		public MemberReferenceExpression(Expression targetObject, MemberInfo memberInfo, params Expression[] arguments)
 		{
 			if (memberInfo == null) throw new ArgumentNullException("memberInfo");
 			

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Expressions/Ast/PrimitiveExpression.cs

@@ -7,6 +7,8 @@
 
 using System;
 
+using Debugger.MetaData;
+
 namespace Debugger.Expressions
 {
 	/// <summary>
@@ -37,8 +39,7 @@ namespace Debugger.Expressions
 		
 		protected override Value EvaluateInternal(StackFrame context)
 		{
-			// TODO: Need for literal method arguments.  Use Eval to create value.
+			return Eval.CreateValue(context.Process, value);
-			throw new NotImplementedException();
 		}
 		
 		#region GetHashCode and Equals

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Expressions/Expression.Create.cs

@@ -31,12 +31,17 @@ namespace Debugger.Expressions
 		
 		public Expression AppendFieldReference(FieldInfo fieldInfo)
 		{
-			return new MemberReferenceExpression(this, fieldInfo, null);
+			return AppendMemberReference(fieldInfo);
 		}
 		
 		public Expression AppendPropertyReference(PropertyInfo propertyInfo)
 		{
-			return new MemberReferenceExpression(this, propertyInfo, null);
+			return AppendMemberReference(propertyInfo);
+		}
+		
+		public Expression AppendMemberReference(MemberInfo memberInfo, params Expression[] args)
+		{
+			return new MemberReferenceExpression(this, memberInfo, args);
 		}
 		
 		public Expression[] AppendObjectMembers(DebugType type, BindingFlags bindingFlags)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Metadata/DebugType.cs

@@ -155,6 +155,18 @@ namespace Debugger.MetaData
 			}
 		}
 		
+		/// <summary> Return an interface with the given name </summary>
+		/// <returns> Null if not found </returns>
+		public DebugType GetInterface(string fullName)
+		{
+			foreach(DebugType inter in this.Interfaces) {
+				if (inter.FullName == fullName) {
+					return inter;
+				}
+			}
+			return null;
+		}
+		
 		/// <summary> Returns generics arguments for a type or an emtpy 
 		/// array for non-generic types. </summary>
 		public DebugType[] GetGenericArguments()
@@ -460,6 +472,12 @@ namespace Debugger.MetaData
 		/// <remarks> Returns false if the given type is same as the current type </remarks>
 		public bool IsSubclassOf(DebugType superType)
 		{
+			// Does this type implement the interface?
+			if (superType.IsInterface) {
+				foreach(DebugType inter in this.Interfaces) {
+					if (inter == superType) return true;
+				}
+			}
 			DebugType type = this.BaseType;
 			while (type != null) {
 				if (type.Equals(superType)) return true;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Values/Value.Object.cs

@@ -99,7 +99,7 @@ namespace Debugger
 			Expression objectInstanceExpression = objectInstance != null ? objectInstance.Expression : new EmptyExpression();
 			return new Value(
 				fieldInfo.Process,
-				new MemberReferenceExpression(objectInstanceExpression, fieldInfo, null),
+				new MemberReferenceExpression(objectInstanceExpression, fieldInfo),
 				GetFieldCorValue(objectInstance, fieldInfo)
 			);
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Values/Value.Primitive.cs

@@ -59,10 +59,12 @@ namespace Debugger
 				if (CorType == CorElementType.STRING) {
 					throw new NotImplementedException();
 				} else {
+					if (value == null) {
+						throw new DebuggerException("Can not set primitive value to null");
+					}
 					object newValue;
-					TypeConverter converter = TypeDescriptor.GetConverter(this.Type.ManagedType);
 					try {
-						newValue = converter.ConvertFrom(value);
+						newValue = Convert.ChangeType(value, this.Type.ManagedType);
 					} catch {
 						throw new NotSupportedException("Can not convert " + value.GetType().ToString() + " to " + this.Type.ManagedType.ToString());
 					}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/Autogenerated/ICorDebugEval.cs

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
@@ -183,7 +183,7 @@ namespace Debugger.Wrappers.CorDebug
 		{
 			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
-			this.WrappedObject.CreateValue(elementType, pElementClass.WrappedObject, out out_ppValue);
+			this.WrappedObject.CreateValue(elementType, pElementClass == null ? null : pElementClass.WrappedObject, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
 			return ppValue;
 		}