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)); }