public override IValuePresentation PresentValue(IStringValueRole <TValue> valueRole, IMetadataTypeLite instanceType,
IPresentationOptions options, IUserDataHolder dataHolder, CancellationToken token)
{
// Note that ValueFlags.IsString will add the "View" link to see a string in a popup. We don't need this
var text = valueRole.GetString();
return(SimplePresentation.CreateSuccess(ValuePresentationPart.Default(text),
valueRole.ValueReference.DefaultFlags | ValueFlags.NoChildren, instanceType, text));
}
public override IValuePresentation PresentValue(IStringValueRole <TValue> valueRole, IMetadataTypeLite instanceType,
IPresentationOptions options, IUserDataHolder dataHolder, CancellationToken token)
{
// Present the value's string as plain text, without any syntax highlighting or quote handling. Don't use
// ValueFlags.IsString, as it will add an unnecessary "View" link - our text is always short
var text = valueRole.GetString();
return(SimplePresentation.CreateSuccess(ValuePresentationPart.Default(text),
valueRole.ValueReference.DefaultFlags | ValueFlags.NoChildren, instanceType, text));
}
// Return null to allow other providers a chance. If we throw EvaluatorException, it will be presented to the
// user. OperationCancelledException will be logged and we move on to the next presenter. Any other exception
// will leak
public override IValuePresentation PresentValue(IObjectValueRole <TValue> valueRole,
IMetadataTypeLite instanceType,
IPresentationOptions options,
IUserDataHolder dataHolder,
CancellationToken token)
{
var debuggerDisplayString = dataHolder.GetData(ourDebuggerDisplayStringKey);
try
{
var valueReference = valueRole.ValueReference;
var thisObj = valueReference.GetValue(options);
var evaluationOptions =
valueReference.OriginatingFrame.DebuggerSession.Options.EvaluationOptions.Apply(options);
// This can throw if there are members missing, which is entirely possible when debugging on a device,
// due to stripping. It will throw EvaluatorException. Anything else is logged and thrown as a new
// EvaluatorException. We can also get InvalidOperationException, but only if no other evaluators can
// handle the current context, which is unlikely
var displayString =
ExpressionEvaluators.EvaluateDisplayString(valueReference.OriginatingFrame, thisObj,
debuggerDisplayString, evaluationOptions, token);
var flags = valueReference.DefaultFlags;
if (valueReference is CalculatedValueReferenceDecorator <TValue> reference &&
!reference.AllowDefaultTypePresentation)
{
flags |= ValueFlags.IsDefaultTypePresentation;
}
return(SimplePresentation.CreateSuccess(
ValuePresentationPart.Default(DisplayStringUtil.EscapeString(displayString)),
flags, instanceType, displayString));
}
catch (Exception ex)
{
// Log as warning, not error - there's nothing the user can do, and we're likely to encounter this with
// device builds
myLogger.Warn(ex,
comment: $"Unable to evaluate debugger display string for type {instanceType.GetGenericTypeDefinition().FullName}: {debuggerDisplayString}. " +
"Expected behaviour on devices due to stripping");
return(null);
}
}
public override IValuePresentation PresentValue(IValueRole <TValue> valueRole,
IMetadataTypeLite instanceType,
IPresentationOptions options,
IUserDataHolder dataHolder,
CancellationToken token)
{
var extraDetail = (ExtraDetailValueReferenceDecorator <TValue>)valueRole.ValueReference;
var presentation = extraDetail.UnderlyingValueReference.ToValue(ValueServices).GetValuePresentation(options, token);
if (presentation.ResultKind == ValueResultKind.Success)
{
var presentationBuilder = PresentationBuilder.New(presentation.Value.ToArray())
.Add(ValuePresentationPart.Space)
.SpecialSymbol("(").Default(extraDetail.ExtraDetail).SpecialSymbol(")");
return(SimplePresentation.CreateSuccess(presentationBuilder.Result(), presentation.Flags,
presentation.Type, presentation.PrimitiveValue));
}
return(presentation);
}
public override IValuePresentation PresentValue(IObjectValueRole <TValue> valueRole,
IMetadataTypeLite instanceType,
IPresentationOptions options, IUserDataHolder dataHolder,
CancellationToken token)
{
var showName = (valueRole.ValueReference as CalculatedValueReferenceDecorator <TValue>)?.AllowNameInValue ?? true;
var showTypeName = (valueRole.ValueReference as CalculatedValueReferenceDecorator <TValue>)
?.AllowDefaultTypePresentation ?? true;
var nameValuePresentation = valueRole.GetInstancePropertyReference("name")?.ToValue(ValueServices)
?.GetValuePresentation(options);
var propertyTypeReference = valueRole.GetInstancePropertyReference("propertyType");
var propertyTypeValuePresentation = propertyTypeReference?.ToValue(ValueServices)?.GetValuePresentation(options);
var propertyTypeEnumValueObject = propertyTypeReference?.AsObjectSafe(options)?.GetEnumValue(options);
var propertyType = (SerializedPropertyKind)Enum.ToObject(typeof(SerializedPropertyKind),
propertyTypeEnumValueObject ?? SerializedPropertyKind.Generic);
int? arraySize = null;
string arrayElementType = null;
string genericType = null;
if (propertyType == SerializedPropertyKind.Generic)
{
if (Util.TryEvaluatePrimitiveProperty(valueRole, "isArray", options, out bool isArray) && isArray)
{
arraySize = valueRole.GetInstancePropertyReference("arraySize")?.AsPrimitiveSafe(options)
?.GetPrimitive <int>();
arrayElementType =
valueRole.GetInstancePropertyReference("arrayElementType")?.AsStringSafe(options)?.GetString();
}
else if (Util.TryEvaluatePrimitiveProperty(valueRole, "isFixedBuffer", options,
out bool isFixedBuffer) &&
isFixedBuffer)
{
arraySize = valueRole.GetInstancePropertyReference("fixedBufferSize")?.AsPrimitiveSafe(options)
?.GetPrimitive <int>();
arrayElementType =
valueRole.GetInstancePropertyReference("arrayElementType")?.AsStringSafe(options)?.GetString();
}
else
{
genericType = valueRole.GetInstancePropertyReference("type")?.AsStringSafe(options)?.GetString();
}
}
var valuePresentation = GetValuePresentation(valueRole, propertyType, options, out var extraDetail);
var parts = PresentationBuilder.New();
parts.OpenBrace();
if (showName && nameValuePresentation != null)
{
parts.Comment("name: ").Add(nameValuePresentation.Value.ToArray())
.Add(ValuePresentationPart.Space);
}
parts.Comment("propertyType: ");
if (propertyType == SerializedPropertyKind.Generic && arraySize != null && arrayElementType != null)
{
parts.Default($"{arrayElementType}[{arraySize}]");
}
else if (genericType != null)
{
parts.Default(genericType);
}
else if (propertyTypeValuePresentation != null)
{
parts.Add(propertyTypeValuePresentation.Value.ToArray());
}
else
{
parts.Comment("(Unknown)");
}
if (valuePresentation != null)
{
parts.Add(ValuePresentationPart.Space)
.Comment("value: ").Add(valuePresentation.Value.ToArray());
if (!string.IsNullOrEmpty(extraDetail))
{
parts.Add(ValuePresentationPart.Space).SpecialSymbol("(").Default(extraDetail).SpecialSymbol(")");
}
}
parts.ClosedBrace();
// Hide the default type presentation if we've been asked to
var flags = !showTypeName ? ValueFlags.IsDefaultTypePresentation : 0;
return(SimplePresentation.Create(parts.Result(), ValueResultKind.Success, ValueFlags.None | flags,
instanceType));
}
public IValuePresentation GetValuePresentation(IPresentationOptions options,
CancellationToken token = new CancellationToken())
{
return(SimplePresentation.Create(PresentationBuilder.New().Error(myMessage), myResultKind,
ValueFlags.NoChildren, DeclaredType));
}
