Add explicit type informations to expressions

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

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Expressions/ExpressionExtensionMethods.cs

@@ -2,7 +2,7 @@
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="David Srbecký" email="dsrbecky@gmail.com"/>
-//     <version>$Revision$</version>
+//     <version>$Revision: 4767 $</version>
 // </file>
 using ICSharpCode.NRefactory.PrettyPrinter;
 using System;
@@ -21,34 +21,63 @@ namespace Debugger
 		
 		public static UnaryOperatorExpression AppendDereference(this Expression expression)
 		{
-			return new UnaryOperatorExpression(expression, UnaryOperatorType.Dereference);
+			return new UnaryOperatorExpression(new ParenthesizedExpression(expression), UnaryOperatorType.Dereference);
 		}
 		
 		public static IndexerExpression AppendIndexer(this Expression expression, params int[] indices)
 		{
-			IndexerExpression indexerExpr = new IndexerExpression(expression, new List<Expression>());
+			IndexerExpression indexerExpr = new IndexerExpression(new ParenthesizedExpression(expression), new List<Expression>());
 			foreach(int index in indices) {
-				indexerExpr.Indexes.Add(new PrimitiveExpression(index));
+				indexerExpr.Indexes.Add(
+					new CastExpression(
+						new TypeReference(typeof(int).FullName),
+						new PrimitiveExpression(index),
+						CastType.Cast
+					)
+				);
 			}
 			return indexerExpr;
 		}
 		
 		public static Expression AppendMemberReference(this Expression expresion, MemberInfo memberInfo, params Expression[] args)
 		{
-			// TODO: Member hidding safety
-			// TODO: Method overload safety
-			Expression target = memberInfo.IsStatic ? new IdentifierExpression(memberInfo.DeclaringType.FullName) : expresion;
+			Expression target;
+			if (memberInfo.IsStatic) {
+				target = new TypeReferenceExpression(
+					memberInfo.DeclaringType.ToTypeReference()
+				);
+			} else {
+				target = new ParenthesizedExpression(
+					new CastExpression(
+						memberInfo.DeclaringType.ToTypeReference(),
+						new ParenthesizedExpression(expresion),
+						CastType.Cast
+					)
+				);
+			}
+			
 			if (memberInfo is FieldInfo) {
-				if (args.Length > 0) throw new DebuggerException("No argumetns expected for a field");
+				if (args.Length > 0)
+					throw new DebuggerException("No arguments expected for a field");
 				return new MemberReferenceExpression(target, memberInfo.Name);
 			}
+			
 			if (memberInfo is MethodInfo) {
-				return new InvocationExpression(new MemberReferenceExpression(target, memberInfo.Name), new List<Expression>(args));
+				return new InvocationExpression(
+					new MemberReferenceExpression(target, memberInfo.Name),
+					AddExplicitTypes((MethodInfo)memberInfo, args)
+				);
 			}
+			
 			if (memberInfo is PropertyInfo) {
+				PropertyInfo propInfo = (PropertyInfo)memberInfo;
 				if (args.Length > 0) {
-					if (memberInfo.Name != "Item") throw new DebuggerException("Arguments expected only for the Item property");
-					return new IndexerExpression(target, new List<Expression>(args));
+					if (memberInfo.Name != "Item")
+						throw new DebuggerException("Arguments expected only for the Item property");
+					return new IndexerExpression(
+						target,
+						AddExplicitTypes(propInfo.GetMethod ?? propInfo.SetMethod, args)
+					);
 				} else {
 					return new MemberReferenceExpression(target, memberInfo.Name);
 				}
@@ -56,6 +85,51 @@ namespace Debugger
 			throw new DebuggerException("Unknown member type " + memberInfo.GetType().FullName);
 		}
 		
+		static List<Expression> AddExplicitTypes(MethodInfo method, Expression[] args)
+		{
+			if (args.Length != method.ParameterCount)
+				throw new DebuggerException("Incorrect number of arguments");
+			List<Expression> typedArgs = new List<Expression>(args.Length);
+			for(int i = 0; i < args.Length; i++) {
+				typedArgs.Add(
+					new CastExpression(
+						method.ParameterTypes[i].ToTypeReference(),
+						new ParenthesizedExpression(args[i]),
+						CastType.Cast
+					)
+				);
+			}
+			return typedArgs;
+		}
+		
+		static TypeReference ToTypeReference(this DebugType type)
+		{
+			List<int> arrayRanks = new List<int>();
+			int pointerNest = 0;
+			while(true) {
+				// TODO: Combined arrays and pointers?
+				// TODO: Check
+				if (type.IsArray) {
+					arrayRanks.Add(type.GetArrayRank() - 1);
+					type = type.ElementType;
+				} else if (type.IsPointer) {
+					pointerNest++;
+					type = type.ElementType;
+				} else {
+					break;
+				}
+			}
+			string name = type.FullName;
+			if (name.IndexOf('<') != -1)
+				name = name.Substring(0, name.IndexOf('<'));
+			List<TypeReference> genArgs = new List<TypeReference>();
+			foreach(DebugType genArg in type.GenericArguments) {
+				genArgs.Add(genArg.ToTypeReference());
+			}
+			TypeReference typeRef = new TypeReference(name, pointerNest, arrayRanks.ToArray(), genArgs);
+			return typeRef;
+		}
+		
 		public static string PrettyPrint(this INode code)
 		{
 			if (code == null) return string.Empty;