[WIP] Revamped expression resolver to have context

Mono.Debugging.Soft/SoftDebuggerBacktrace.cs

@@ -210,7 +210,7 @@ DC.StackFrame CreateStackFrame (MDB.StackFrame frame, int frameIndex)
 			return new SoftDebuggerStackFrame (frame, addressSpace, location, language, external, hasDebugInfo, hidden, typeFQN, typeFullName);
 		}
 
-		protected override EvaluationContext GetEvaluationContext (int frameIndex, EvaluationOptions options)
+		public override EvaluationContext GetEvaluationContext (int frameIndex, EvaluationOptions options)
 		{
 			ValidateStack ();
 

Mono.Debugging.Soft/SoftDebuggerSession.cs

@@ -2372,7 +2372,7 @@ string EvaluateExpression (ThreadMirror thread, string expression, BreakEvent bp
 
 					// resolve types...
 					if (ctx.SourceCodeAvailable)
-						expression = ctx.Evaluator.Resolve (this, GetSourceLocation (frames[0]), expression);
+						expression = ctx.Evaluator.Resolve (this, ctx, GetSourceLocation (frames[0]), expression);
 				}
 
 				ValueReference val = ctx.Evaluator.Evaluate (ctx, expression);

Mono.Debugging.Win32/CorDebuggerBacktrace.cs

@@ -64,7 +64,7 @@ internal List<CorFrame> FrameList {
 			}
 		}
 
-		protected override EvaluationContext GetEvaluationContext (int frameIndex, EvaluationOptions options)
+		public override EvaluationContext GetEvaluationContext (int frameIndex, EvaluationOptions options)
 		{
 			var ctx = new CorEvaluationContext (session, this, frameIndex, options);
 			ctx.Thread = thread;

Mono.Debugging/Mono.Debugging.Backend/IBacktrace.cs

@@ -1,5 +1,6 @@
 
 using Mono.Debugging.Client;
+using Mono.Debugging.Evaluation;
 
 namespace Mono.Debugging.Backend
 {
@@ -12,6 +13,7 @@ public interface IBacktrace: IDebuggerBackendObject
 		ObjectValue GetThisReference (int frameIndex, EvaluationOptions options);
 		ExceptionInfo GetException (int frameIndex, EvaluationOptions options);
 		ObjectValue[] GetAllLocals (int frameIndex, EvaluationOptions options);
+		EvaluationContext GetEvaluationContext (int frameIndex, EvaluationOptions options);
 		ObjectValue[] GetExpressionValues (int frameIndex, string[] expressions, EvaluationOptions options);
 		CompletionData GetExpressionCompletionData (int frameIndex, string exp);
 		AssemblyLine[] Disassemble (int frameIndex, int firstLine, int count);

Mono.Debugging/Mono.Debugging.Client/DebuggerSession.cs

@@ -890,18 +890,18 @@ public AssemblyLine[] DisassembleFile (string file)
 			}
 		}
 
-		public string ResolveExpression (string expression, string file, int line, int column, int endLine, int endColumn)
+		public string ResolveExpression (EvaluationContext ctx, string expression, string file, int line, int column, int endLine, int endColumn)
 		{
-			return ResolveExpression (expression, new SourceLocation (null, file, line, column, endLine, endColumn, null, null));
+			return ResolveExpression (ctx, expression, new SourceLocation (null, file, line, column, endLine, endColumn, null, null));
 		}
 
-		public virtual string ResolveExpression (string expression, SourceLocation location)
+		public virtual string ResolveExpression (EvaluationContext ctx, string expression, SourceLocation location)
 		{
 			var key = expression + " " + location;
 
 			if (!resolvedExpressionCache.TryGetValue (key, out var resolved)) {
 				try {
-					resolved = OnResolveExpression (expression, location);
+					resolved = OnResolveExpression (ctx, expression, location);
 				} catch (Exception ex) {
 					OnDebuggerOutput (true, "Error while resolving expression: " + ex.Message);
 				}
@@ -992,13 +992,13 @@ protected void RaiseStopEvent ()
 		/// <returns>
 		/// The resolved expression
 		/// </returns>
-		protected virtual string OnResolveExpression (string expression, SourceLocation location)
+		protected virtual string OnResolveExpression (EvaluationContext ctx, string expression, SourceLocation location)
 		{
 			var resolver = defaultResolver;
 			if (GetExpressionEvaluator != null)
 				resolver = GetExpressionEvaluator(System.IO.Path.GetExtension(location.FileName))?.Evaluator ?? defaultResolver;
 
-			return resolver.Resolve(this, location, expression);
+			return resolver.Resolve (this, ctx, location, expression);
 		}
 
 		internal protected string ResolveIdentifierAsType (string identifier, SourceLocation location)

Mono.Debugging/Mono.Debugging.Client/StackFrame.cs

@@ -3,6 +3,7 @@
 using System.Threading;
 
 using Mono.Debugging.Backend;
+using Mono.Debugging.Evaluation;
 
 namespace Mono.Debugging.Client
 {
@@ -272,9 +273,9 @@ public ExceptionInfo GetException (EvaluationOptions options)
 			return value;
 		}
 
-		public string ResolveExpression (string exp)
+		public string ResolveExpression (EvaluationContext ctx, string expression)
 		{
-			return session.ResolveExpression (exp, location);
+			return session.ResolveExpression (ctx, expression, location);
 		}
 
 		public ObjectValue[] GetExpressionValues (string[] expressions, bool evaluateMethods)
@@ -297,9 +298,11 @@ public ObjectValue[] GetExpressionValues (string[] expressions, EvaluationOption
 			}
 
 			if (options.UseExternalTypeResolver) {
+				var ctx = sourceBacktrace.GetEvaluationContext (index, options);
+
 				var resolved = new string [expressions.Length];
 				for (int n = 0; n < expressions.Length; n++)
-					resolved[n] = ResolveExpression (expressions[n]);
+					resolved[n] = ResolveExpression (ctx, expressions[n]);
 
 				expressions = resolved;
 			}
@@ -323,8 +326,11 @@ public ObjectValue GetExpressionValue (string expression, EvaluationOptions opti
 				return ObjectValue.CreateUnknown (expression);
 			}
 
-			if (options.UseExternalTypeResolver)
-				expression = ResolveExpression (expression);
+			if (options.UseExternalTypeResolver) {
+				var ctx = sourceBacktrace.GetEvaluationContext (index, options);
+
+				expression = ResolveExpression (ctx, expression);
+			}
 
 			var values = sourceBacktrace.GetExpressionValues (index, new [] { expression }, options);
 			ObjectValue.ConnectCallbacks (this, values);
@@ -344,8 +350,11 @@ public bool ValidateExpression (string expression)
 		/// </summary>
 		public ValidationResult ValidateExpression (string expression, EvaluationOptions options)
 		{
-			if (options.UseExternalTypeResolver)
-				expression = ResolveExpression (expression);
+			if (options.UseExternalTypeResolver) {
+				var ctx = sourceBacktrace.GetEvaluationContext (index, options);
+
+				expression = ResolveExpression (ctx, expression);
+			}
 
 			return sourceBacktrace.ValidateExpression (index, expression, options);
 		}

Mono.Debugging/Mono.Debugging.Evaluation/BaseBacktrace.cs

@@ -45,7 +45,7 @@ protected BaseBacktrace (ObjectValueAdaptor adaptor)
 
 		public ObjectValueAdaptor Adaptor { get; set; }
 
-		protected abstract EvaluationContext GetEvaluationContext (int frameIndex, EvaluationOptions options);
+		public abstract EvaluationContext GetEvaluationContext (int frameIndex, EvaluationOptions options);
 
 		public abstract int FrameCount { get; }
 

Mono.Debugging/Mono.Debugging.Evaluation/ExpressionEvaluator.cs

@@ -183,13 +183,18 @@ public virtual bool CaseSensitive {
 			get { return true; }
 		}
 
-		public abstract string Resolve (DebuggerSession session, SourceLocation location, string expression);
+		public abstract string Resolve (DebuggerSession session, EvaluationContext ctx, SourceLocation location, string expression);
 
 		public virtual IEnumerable<ValueReference> GetLocalVariables (EvaluationContext ctx)
 		{
 			return ctx.Adapter.GetLocalVariables (ctx);
 		}
 
+		public virtual ValueReference GetLocalVariable (EvaluationContext ctx, string name)
+		{
+			return ctx.Adapter.GetLocalVariable (ctx, name);
+		}
+
 		public virtual ValueReference GetThisReference (EvaluationContext ctx)
 		{
 			return ctx.Adapter.GetThisReference (ctx);
@@ -200,6 +205,11 @@ public virtual IEnumerable<ValueReference> GetParameters (EvaluationContext ctx)
 			return ctx.Adapter.GetParameters (ctx);
 		}
 
+		public virtual ValueReference GetParameter (EvaluationContext ctx, string name)
+		{
+			return ctx.Adapter.GetParameter (ctx, name);
+		}
+
 		public virtual ValueReference GetCurrentException (EvaluationContext ctx)
 		{
 			return ctx.Adapter.GetCurrentException (ctx);

Mono.Debugging/Mono.Debugging.Evaluation/NRefactoryExpressionEvaluator.cs

@@ -83,36 +83,36 @@ public override ValueReference Evaluate (EvaluationContext ctx, string expressio
 			return expr.AcceptVisitor (evaluator);
 		}
 
-		public override string Resolve (DebuggerSession session, SourceLocation location, string exp)
+		public override string Resolve (DebuggerSession session, EvaluationContext ctx, SourceLocation location, string expression)
 		{
-			return Resolve (session, location, exp, false);
+			return Resolve (session, ctx, location, expression, false);
 		}
 
-		string Resolve (DebuggerSession session, SourceLocation location, string expression, bool tryTypeOf)
+		string Resolve (DebuggerSession session, EvaluationContext ctx, SourceLocation location, string expression, bool tryTypeOf)
 		{
 			expression = expression.Trim ();
 
 			if (expression.Length > 0 && expression[0] == '?')
-				return "?" + Resolve (session, location, expression.Substring (1).Trim ());
+				return "?" + Resolve (session, ctx, location, expression.Substring (1).TrimStart ());
 
 			if (expression.Length > 3 && expression.StartsWith ("var", StringComparison.Ordinal) && char.IsWhiteSpace (expression[3]))
-				return "var " + Resolve (session, location, expression.Substring (4).Trim (' ', '\t'));
+				return "var " + Resolve (session, ctx, location, expression.Substring (4).TrimStart ());
 
 			expression = ReplaceExceptionTag (expression, session.Options.EvaluationOptions.CurrentExceptionTag);
 
 			var expr = new CSharpParser ().ParseExpression (expression);
 			if (expr == null)
 				return expression;
 
-			var resolver = new NRefactoryExpressionResolverVisitor (session, location, expression);
+			var resolver = new NRefactoryExpressionResolverVisitor (this, session, ctx, location, expression);
 			expr.AcceptVisitor (resolver);
 
 			string resolved = resolver.GetResolvedExpression ();
 			if (resolved == expression && !tryTypeOf && (expr is BinaryOperatorExpression) && IsTypeName (expression)) {
 				// This is a hack to be able to parse expressions such as "List<string>". The NRefactory parser
 				// can parse a single type name, so a solution is to wrap it around a typeof(). We do it if
 				// the evaluation fails.
-				string res = Resolve (session, location, "typeof(" + expression + ")", true);
+				string res = Resolve (session, ctx, location, "typeof(" + expression + ")", true);
 				return res.Substring (7, res.Length - 8);
 			}
 

Mono.Debugging/Mono.Debugging.Evaluation/NRefactoryExpressionResolverVisitor.cs

@@ -24,6 +24,7 @@
 // THE SOFTWARE.
 
 using System;
+using System.Linq;
 using System.Text;
 using System.Collections.Generic;
 
@@ -38,8 +39,10 @@ namespace Mono.Debugging.Evaluation
 	public class NRefactoryExpressionResolverVisitor : DepthFirstAstVisitor
 	{
 		readonly List<Replacement> replacements = new List<Replacement> ();
+		readonly ExpressionEvaluator evaluator;
 		readonly SourceLocation location;
 		readonly DebuggerSession session;
+		readonly EvaluationContext ctx;
 		readonly string expression;
 		string parentType;
 
@@ -50,11 +53,13 @@ class Replacement
 			public int Length;
 		}
 
-		public NRefactoryExpressionResolverVisitor (DebuggerSession session, SourceLocation location, string expression)
+		public NRefactoryExpressionResolverVisitor (ExpressionEvaluator evaluator, DebuggerSession session, EvaluationContext ctx, SourceLocation location, string expression)
 		{
 			this.expression = expression.Replace ("\n", "").Replace ("\r", "");
+			this.evaluator = evaluator;
 			this.session = session;
 			this.location = location;
+			this.ctx = ctx;
 		}
 
 		internal string GetResolvedExpression ()
@@ -128,8 +133,17 @@ public override void VisitIdentifierExpression (IdentifierExpression identifierE
 
 			int length = identifierExpression.IdentifierToken.EndLocation.Column - identifierExpression.IdentifierToken.StartLocation.Column;
 			int offset = identifierExpression.IdentifierToken.StartLocation.Column - 1;
+			var name = identifierExpression.Identifier;
 
-			ReplaceType (identifierExpression.Identifier, identifierExpression.TypeArguments.Count, offset, length);
+			// check if the identifier is a local variable or a member variable
+			if (evaluator.GetLocalVariable (ctx, name) != null)
+				return;
+
+			var thisReference = evaluator.GetThisReference (ctx);
+			if (thisReference != null && thisReference.GetChild (name, ctx.Options) != null)
+				return;
+
+			ReplaceType (name, identifierExpression.TypeArguments.Count, offset, length);
 		}
 
 		public override void VisitTypeReferenceExpression (TypeReferenceExpression typeReferenceExpression)

Mono.Debugging/Mono.Debugging.Evaluation/ObjectValueAdaptor.cs

@@ -730,7 +730,7 @@ protected virtual ValueReference OnGetLocalVariable (EvaluationContext ctx, stri
 			return best;
 		}
 
-		public virtual ValueReference GetParameter (EvaluationContext ctx, string name)
+		public ValueReference GetParameter (EvaluationContext ctx, string name)
 		{
 			return OnGetParameter (ctx, name);
 		}