Value Visit(ConversionResolveResult result)
{
if (result.IsError)
{
throw new GetValueException("Cannot convert from '{0}' to '{1}'.", new CSharpAmbience().ConvertType(result.Input.Type), new CSharpAmbience().ConvertType(result.Type));
}
var val = Convert(result.Input);
if (result.Conversion.IsBoxingConversion)
{
return(val);
}
if (result.Conversion.IsIdentityConversion)
{
return(val);
}
if (result.Conversion.IsNumericConversion)
{
var convVal = CSharpPrimitiveCast.Cast(ReflectionHelper.GetTypeCode(result.Type), val.PrimitiveValue, false);
return(Eval.CreateValue(evalThread, convVal));
}
if (result.Conversion.IsUserDefined)
{
return(InvokeMethod(null, result.Conversion.Method, val));
}
if (result.Conversion.IsReferenceConversion && result.Conversion.IsImplicit)
{
return(val);
}
if (result.Conversion.IsNullLiteralConversion)
{
return(val);
}
throw new GetValueException("conversion '{0}' not implemented!", result.Conversion);
}
/// <remarks>
/// See $7.10.10 of C# 4 Spec for details.
/// </remarks>
Value Visit(TypeIsResolveResult result)
{
var importedType = NullableType.GetUnderlyingType(Import(result.TargetType));
var val = Convert(result.Input);
var conversions = CSharpConversions.Get(debuggerTypeSystem);
bool evalResult = false;
if (!val.IsNull)
{
IType inputType = NullableType.GetUnderlyingType(val.Type);
if (inputType.Equals(importedType))
{
evalResult = true;
}
else if (conversions.IsImplicitReferenceConversion(inputType, importedType))
{
evalResult = true;
}
else if (conversions.IsBoxingConversion(inputType, importedType))
{
evalResult = true;
}
}
return(Eval.CreateValue(evalThread, evalResult));
}
public Value Convert(ResolveResult result)
{
if (result.IsCompileTimeConstant && !result.IsError)
{
return(Eval.CreateValue(evalThread, result.ConstantValue));
}
return(Visit((dynamic)result));
}
public Value Convert(ResolveResult result)
{
if (result.IsCompileTimeConstant && !result.IsError)
{
var type = Import(result.Type);
if (type == null)
{
throw new GetValueException("Error: cannot find '{0}'.", result.Type.FullName);
}
return(Eval.CreateValue(evalThread, result.ConstantValue, type));
}
return(Visit((dynamic)result));
}
public static Value MakeValue(object obj)
{
Value v = null;
if (!(obj is string))
{
v = Eval.CreateValue(WorkbenchServiceFactory.DebuggerManager.DebuggedProcess, obj);
v.SetPrimitiveValue(obj);
}
else
{
v = Eval.NewString(WorkbenchServiceFactory.DebuggerManager.DebuggedProcess, obj as string);
}
return(v);
}
public override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
{
if (primitiveExpression.Value == null)
{
return(Eval.CreateValue(context.Process, null));
}
else if (primitiveExpression.Value is string)
{
return(Eval.NewString(context.Process, primitiveExpression.Value as string));
}
else
{
Value val = Eval.NewObjectNoConstructor(DebugType.Create(context.Process, null, primitiveExpression.Value.GetType().FullName));
val.PrimitiveValue = primitiveExpression.Value;
return(val);
}
}
Value Visit(ResolveResult result)
{
if (result is ErrorResolveResult)
{
var err = (ErrorResolveResult)result;
if (!string.IsNullOrWhiteSpace(err.Message))
{
throw new GetValueException(err.Message);
}
}
if (result.IsError)
{
throw new GetValueException("Unknown error");
}
if (result.ConstantValue == null && result.Type.Equals(SpecialType.NullType))
{
return(Eval.CreateValue(evalThread, null));
}
throw new GetValueException("Unsupported language construct: " + result.GetType().Name);
}
public static string FormatValue(Thread evalThread, Value val)
{
if (val.IsNull)
{
return("null");
}
else if (val.Type.Kind == TypeKind.Array)
{
StringBuilder sb = new StringBuilder();
sb.Append(new CSharpAmbience().ConvertType(val.Type));
sb.Append(" {");
bool first = true;
int size = val.ArrayLength;
for (int i = 0; i < size; i++)
{
if (!first)
{
sb.Append(", ");
}
first = false;
sb.Append(FormatValue(evalThread, val.GetElementAtPosition(i)));
}
sb.Append("}");
return(sb.ToString());
}
else if (val.Type.GetAllBaseTypeDefinitions().Any(def => def.IsKnownType(KnownTypeCode.ICollection)))
{
StringBuilder sb = new StringBuilder();
sb.Append(new CSharpAmbience().ConvertType(val.Type));
sb.Append(" {");
val = val.GetPermanentReference(evalThread);
var countProp = val.Type.GetProperties(p => p.Name == "Count" && !p.IsExplicitInterfaceImplementation).Single();
int count = (int)val.GetMemberValue(evalThread, countProp).PrimitiveValue;
for (int i = 0; i < count; i++)
{
if (i > 0)
{
sb.Append(", ");
}
var itemProperty = val.Type.GetProperties(p => p.IsIndexer && p.Name == "Item" && !p.IsExplicitInterfaceImplementation).Single();
Value item = val.GetPropertyValue(evalThread, itemProperty, Eval.CreateValue(evalThread, i));
sb.Append(FormatValue(evalThread, item));
}
sb.Append("}");
return(sb.ToString());
}
else if (val.Type.IsKnownType(KnownTypeCode.String) || val.Type.IsPrimitiveType())
{
return(TextWriterTokenWriter.PrintPrimitiveValue(val.PrimitiveValue));
}
else
{
return(val.InvokeToString(evalThread));
}
}
Value VisitBinaryOperator(OperatorResolveResult result, BinaryOperatorType operatorType, bool checkForOverflow = false)
{
Debug.Assert(result.Operands.Count == 2);
Debug.Assert(operatorType != BinaryOperatorType.ConditionalAnd && operatorType != BinaryOperatorType.ConditionalOr && operatorType != BinaryOperatorType.NullCoalescing);
var lhs = Convert(result.Operands[0]).GetPermanentReference(evalThread);
var rhs = Convert(result.Operands[1]).GetPermanentReference(evalThread);
if (result.UserDefinedOperatorMethod != null)
{
return(InvokeMethod(null, result.UserDefinedOperatorMethod, lhs, rhs));
}
var lhsRR = lhs.ToResolveResult(context);
var rhsRR = rhs.ToResolveResult(context);
CSharpResolver resolver = new CSharpResolver(debuggerTypeSystem).WithCheckForOverflow(checkForOverflow);
var val = resolver.ResolveBinaryOperator(operatorType, lhsRR, rhsRR);
if (val.IsCompileTimeConstant)
{
return(Convert(val));
}
switch (operatorType)
{
case BinaryOperatorType.Equality:
case BinaryOperatorType.InEquality:
bool equality = (operatorType == BinaryOperatorType.Equality);
if (lhsRR.Type.IsKnownType(KnownTypeCode.String) && rhsRR.Type.IsKnownType(KnownTypeCode.String))
{
if (lhs.IsNull || rhs.IsNull)
{
bool bothNull = lhs.IsNull && rhs.IsNull;
return(Eval.CreateValue(evalThread, equality ? bothNull : !bothNull));
}
else
{
bool equal = (string)lhs.PrimitiveValue == (string)rhs.PrimitiveValue;
return(Eval.CreateValue(evalThread, equality ? equal : !equal));
}
}
if (lhsRR.Type.IsReferenceType != false && rhsRR.Type.IsReferenceType != false)
{
// Reference comparison
if (lhs.IsNull || rhs.IsNull)
{
bool bothNull = lhs.IsNull && rhs.IsNull;
return(Eval.CreateValue(evalThread, equality ? bothNull : !bothNull));
}
else
{
bool equal = lhs.Address == rhs.Address;
return(Eval.CreateValue(evalThread, equality ? equal : !equal));
}
}
goto default;
case BinaryOperatorType.Add:
if (lhsRR.Type.IsKnownType(KnownTypeCode.String) || rhsRR.Type.IsKnownType(KnownTypeCode.String))
{
var method = debuggerTypeSystem.FindType(KnownTypeCode.String)
.GetMethods(m => m.Name == "Concat" && m.Parameters.Count == 2)
.Single(m => m.Parameters.All(p => p.Type.IsKnownType(KnownTypeCode.Object)));
return(InvokeMethod(null, method, lhs, rhs));
}
goto default;
default:
throw new GetValueException("Operator {0} is not supported for {1} and {2}!", operatorType, new CSharpAmbience().ConvertType(lhsRR.Type), new CSharpAmbience().ConvertType(rhsRR.Type));
}
}
/// <remarks> 'getValue' really should return cached value, because we do Eval to create indices. </remarks>
static IEnumerable <TreeNode> GetIListChildren(Func <Value> getValue)
{
IProperty itemProp;
int count = 0;
try {
Value list = getValue();
IType iListType = list.Type.GetAllBaseTypeDefinitions().FirstOrDefault(t => t.FullName == typeof(IList).FullName);
itemProp = iListType.GetProperties(p => p.Name == "Item").Single();
// Do not get string representation since it can be printed in hex
count = (int)list.GetPropertyValue(WindowsDebugger.EvalThread, iListType.GetProperties(p => p.Name == "Count").Single()).PrimitiveValue;
} catch (GetValueException e) {
return(new [] { new TreeNode(null, "(error)", e.Message, string.Empty, null) });
}
if (count == 0)
{
return(new [] { new TreeNode("(empty)", null) });
}
else
{
return(Enumerable.Range(0, count).Select(i => new ValueNode(ClassBrowserIconService.Field, "[" + i + "]", () => getValue().GetPropertyValue(WindowsDebugger.EvalThread, itemProp, Eval.CreateValue(WindowsDebugger.EvalThread, i)))));
}
}
protected override Value EvaluateInternal(StackFrame context)
{
return(Eval.CreateValue(context.Process, this.Value));
}
public void Refresh()
{
try {
// clear ListView
listView.ItemsSource = null;
Value shownValue = getValue();
ParameterizedType iListType, iEnumerableType;
IType itemType;
// Value is IList
if (shownValue.Type.ResolveIListImplementation(out iListType, out itemType))
{
// Ok
}
else
{
// Value is IEnumerable
if (shownValue.Type.ResolveIEnumerableImplementation(out iEnumerableType, out itemType))
{
shownValue = DebuggerHelpers.CreateListFromIEnumerable(shownValue);
shownValue.Type.ResolveIListImplementation(out iListType, out itemType);
//var ilistDef = iEnumerableType.Compilation.FindType(typeof(List<>)).GetDefinition();
//var ilistType = new ParameterizedType(ilistDef, ienumerableType.TypeArguments);
}
else
{
// Not IList or IEnumerable<T> - can't be displayed in GridVisualizer
return;
}
}
shownValue = shownValue.GetPermanentReference(WindowsDebugger.EvalThread);
var members = itemType.GetFieldsAndNonIndexedProperties().Where(m => m.IsPublic && !m.IsStatic).ToList();
IProperty indexerProperty = iListType.GetProperties(p => p.Name == "Item").Single();
int rowCount = (int)shownValue.GetPropertyValue(WindowsDebugger.EvalThread, iListType.GetProperties(p => p.Name == "Count").Single()).PrimitiveValue;
int columnCount = members.Count + 1;
var rowCollection = new VirtualizingCollection <VirtualizingCollection <string> >(
rowCount,
(rowIndex) => new VirtualizingCollection <string>(
columnCount,
(columnIndex) => {
if (columnIndex == columnCount - 1)
{
return("[" + rowIndex + "]");
}
try {
var rowValue = shownValue.GetPropertyValue(WindowsDebugger.EvalThread, indexerProperty, Eval.CreateValue(WindowsDebugger.EvalThread, rowIndex));
return(rowValue.GetMemberValue(WindowsDebugger.EvalThread, members[columnIndex]).InvokeToString(WindowsDebugger.EvalThread));
} catch (GetValueException e) {
return("Exception: " + e.Message);
}
}
)
);
this.listView.ItemsSource = rowCollection;
InitializeColumns((GridView)this.listView.View, members);
GridViewColumnHider columnHider = new GridViewColumnHider((GridView)this.listView.View);
cmbColumns.ItemsSource = columnHider.HideableColumns;
} catch (GetValueException e) {
MessageService.ShowMessage(e.Message);
}
}
