java/debugger/impl/src/com/intellij/debugger/ui/impl/watch/ValueDescriptorImpl.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2009 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.debugger.ui.impl.watch;

 import com.intellij.Patches;
 import com.intellij.debugger.DebuggerContext;
 import com.intellij.debugger.engine.*;
 import com.intellij.debugger.engine.evaluation.EvaluateException;
 import com.intellij.debugger.engine.evaluation.EvaluationContextImpl;
 import com.intellij.debugger.engine.events.SuspendContextCommandImpl;
 import com.intellij.debugger.impl.DebuggerContextImpl;
 import com.intellij.debugger.jdi.VirtualMachineProxyImpl;
 import com.intellij.debugger.settings.NodeRendererSettings;
 import com.intellij.debugger.ui.tree.DebuggerTreeNode;
 import com.intellij.debugger.ui.tree.NodeDescriptor;
 import com.intellij.debugger.ui.tree.ValueDescriptor;
 import com.intellij.debugger.ui.tree.render.*;
 import com.intellij.debugger.ui.tree.render.Renderer;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiExpression;
 import com.intellij.util.StringBuilderSpinAllocator;
 import com.intellij.util.concurrency.Semaphore;
 import com.intellij.xdebugger.impl.ui.tree.ValueMarkup;
 import com.sun.jdi.*;
 import org.jetbrains.annotations.Nullable;

 import javax.swing.*;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;

 public abstract class ValueDescriptorImpl extends NodeDescriptorImpl implements ValueDescriptor{
   protected final Project myProject;

   NodeRenderer myRenderer = null;

   NodeRenderer myAutoRenderer = null;

   private Value myValue;
   private boolean myValueReady;

   private EvaluateException myValueException;
   protected EvaluationContextImpl myStoredEvaluationContext = null;

   private String myValueText;
   private String myValueLabel;
   @Nullable
   private Icon myValueIcon;

   protected boolean myIsNew = true;
   private boolean myIsDirty = false;
   private boolean myIsLvalue = false;
   private boolean myIsExpandable;

   private boolean myShowIdLabel = true;

   protected ValueDescriptorImpl(Project project, Value value) {
     myProject = project;
     myValue = value;
     myValueReady = true;
   }

   protected ValueDescriptorImpl(Project project) {
     myProject = project;
   }

   private void assertValueReady() {
     if (!myValueReady) {
       LOG.error("Value is not yet calculated for " + getClass());
     }
   }

   @Override
   public boolean isArray() {
     assertValueReady();
     return myValue instanceof ArrayReference;
   }

   public boolean isDirty() {
     assertValueReady();
     return myIsDirty;
   }

   @Override
   public boolean isLvalue() {
     assertValueReady();
     return myIsLvalue;
   }

   @Override
   public boolean isNull() {
     assertValueReady();
     return myValue == null;
   }

   @Override
   public boolean isString() {
     assertValueReady();
     return myValue instanceof StringReference;
   }

   @Override
   public boolean isPrimitive() {
     assertValueReady();
     return myValue instanceof PrimitiveValue;
   }

   public boolean isValueValid() {
     return myValueException == null;
   }

   public boolean isShowIdLabel() {
     return myShowIdLabel;
   }

   public void setShowIdLabel(boolean showIdLabel) {
     myShowIdLabel = showIdLabel;
   }

   @Override
   public Value getValue() {
     // the following code makes sense only if we do not use ObjectReference.enableCollection() / disableCollection()
     // to keep temporary objects
     if (Patches.IBM_JDK_DISABLE_COLLECTION_BUG) {
       final EvaluationContextImpl evalContext = myStoredEvaluationContext;
       if (evalContext != null && !evalContext.getSuspendContext().isResumed() &&
         myValue instanceof ObjectReference && VirtualMachineProxyImpl.isCollected((ObjectReference)myValue)) {

         final Semaphore semaphore = new Semaphore();
         semaphore.down();
         evalContext.getDebugProcess().getManagerThread().invoke(new SuspendContextCommandImpl(evalContext.getSuspendContext()) {
           @Override
           public void contextAction() throws Exception {
             // re-setting the context will cause value recalculation
             try {
               setContext(myStoredEvaluationContext);
             }
             finally {
               semaphore.up();
             }
           }

           @Override
           protected void commandCancelled() {
             semaphore.up();
           }
         });
         semaphore.waitFor();
       }
     }

     assertValueReady();
     return myValue;
   }

   @Override
   public boolean isExpandable() {
     return myIsExpandable;
   }

   public abstract Value calcValue(EvaluationContextImpl evaluationContext) throws EvaluateException;

   @Override
   public final void setContext(EvaluationContextImpl evaluationContext) {
     DebuggerManagerThreadImpl.assertIsManagerThread();
     myStoredEvaluationContext = evaluationContext;
     Value value;
     try {
       value = calcValue(evaluationContext);

       if(!myIsNew) {
         try {
           if (myValue instanceof DoubleValue && Double.isNaN(((DoubleValue)myValue).doubleValue())) {
             myIsDirty = !(value instanceof DoubleValue);
           }
           else if (myValue instanceof FloatValue && Float.isNaN(((FloatValue)myValue).floatValue())) {
             myIsDirty = !(value instanceof FloatValue);
           }
           else {
             myIsDirty = (value == null) ? myValue != null : !value.equals(myValue);
           }
         }
         catch (ObjectCollectedException ignored) {
           myIsDirty = true;
         }
       }
       myValue = value;
       myValueException = null;
     }
     catch (EvaluateException e) {
       myValueException = e;
       setFailed(e);
       myValue = getTargetExceptionWithStackTraceFilled(evaluationContext, e);
       myIsExpandable = false;
     }
     finally {
       myValueReady = true;
     }

     myIsNew = false;
   }

   @Nullable
   private static ObjectReference getTargetExceptionWithStackTraceFilled(final EvaluationContextImpl evaluationContext, EvaluateException ex){
     final ObjectReference exceptionObj = ex.getExceptionFromTargetVM();
     if (exceptionObj != null && evaluationContext != null) {
       try {
         final ReferenceType refType = exceptionObj.referenceType();
         final List<Method> methods = refType.methodsByName("getStackTrace", "()[Ljava/lang/StackTraceElement;");
         if (methods.size() > 0) {
           final DebugProcessImpl process = evaluationContext.getDebugProcess();
           process.invokeMethod(evaluationContext, exceptionObj, methods.get(0), Collections.emptyList());

           // print to console as well

           final Field traceField = refType.fieldByName("stackTrace");
           final Value trace = traceField != null? exceptionObj.getValue(traceField) : null;
           if (trace instanceof ArrayReference) {
             final ArrayReference traceArray = (ArrayReference)trace;
             final Type componentType = ((ArrayType)traceArray.referenceType()).componentType();
             if (componentType instanceof ClassType) {
               process.printToConsole(DebuggerUtils.getValueAsString(evaluationContext, exceptionObj));
               process.printToConsole("\n");
               for (Value stackElement : traceArray.getValues()) {
                 process.printToConsole("\tat ");
                 process.printToConsole(DebuggerUtils.getValueAsString(evaluationContext, stackElement));
                 process.printToConsole("\n");
               }
             }
           }
         }
       }
       catch (EvaluateException ignored) {
       }
       catch (ClassNotLoadedException ignored) {
       }
       catch (Throwable e) {
         LOG.info(e); // catch all exceptions to ensure the method returns gracefully
       }
     }
     return exceptionObj;
   }

   @Override
   public void setAncestor(NodeDescriptor oldDescriptor) {
     super.setAncestor(oldDescriptor);
     myIsNew = false;
     ValueDescriptorImpl other = (ValueDescriptorImpl)oldDescriptor;
     if (other.myValueReady) {
       myValue = other.getValue();
       myValueReady = true;
     }
   }

   protected void setLvalue(boolean value) {
     myIsLvalue = value;
   }

   @Override
   protected String calcRepresentation(EvaluationContextImpl context, DescriptorLabelListener labelListener){
     DebuggerManagerThreadImpl.assertIsManagerThread();

     final NodeRenderer renderer = getRenderer(context.getDebugProcess());

     final EvaluateException valueException = myValueException;
     myIsExpandable = (valueException == null || valueException.getExceptionFromTargetVM() != null) && renderer.isExpandable(getValue(), context, this);

     try {
       setValueIcon(renderer.calcValueIcon(this, context, labelListener));
     }
     catch (EvaluateException e) {
       LOG.info(e);
       setValueIcon(null);
     }

     String label;
     if (valueException == null) {
       try {
         label = renderer.calcLabel(this, context, labelListener);
       }
       catch (EvaluateException e) {
         label = setValueLabelFailed(e);
       }
     }
     else {
       label = setValueLabelFailed(valueException);
     }

     return setValueLabel(label);
   }

   private String getCustomLabel(String label) {
     //translate only strings in quotes
     String customLabel = null;
     if(isShowIdLabel() && myValueReady) {
       final Value value = getValue();
       Renderer lastRenderer = getLastRenderer();
       final EvaluationContextImpl evalContext = myStoredEvaluationContext;
       final String idLabel = evalContext != null && lastRenderer != null && !evalContext.getSuspendContext().isResumed()?
                              ((NodeRendererImpl)lastRenderer).getIdLabel(value, evalContext.getDebugProcess()) :
                              null;
       if(idLabel != null && !label.startsWith(idLabel)) {
         customLabel = idLabel;
       }
     }
     final String originalLabel = label == null ? "null" : label;
     return customLabel == null? originalLabel : customLabel + originalLabel;
   }


   @Override
   public String setValueLabel(String label) {
     myValueText = label;
     final String customLabel = getCustomLabel(label);
     myValueLabel = customLabel;
     return setLabel(calcValueName() + " = " + customLabel);
   }

   @Override
   public String setValueLabelFailed(EvaluateException e) {
     final String label = setFailed(e);
     setValueLabel(label);
     return label;
   }

   @Override
   public Icon setValueIcon(Icon icon) {
     return myValueIcon = icon;
   }

   @Nullable
   public Icon getValueIcon() {
     return myValueIcon;
   }

   public abstract String calcValueName();

   @Override
   public void displayAs(NodeDescriptor descriptor) {
     if (descriptor instanceof ValueDescriptorImpl) {
       ValueDescriptorImpl valueDescriptor = (ValueDescriptorImpl)descriptor;
       myRenderer = valueDescriptor.myRenderer;
     }
     super.displayAs(descriptor);
   }

   public Renderer getLastRenderer() {
     return myRenderer != null ? myRenderer: myAutoRenderer;
   }

   @Nullable
   public Type getType() {
     Value value = getValue();
     return value != null ? value.type() : null;
   }

   public NodeRenderer getRenderer (DebugProcessImpl debugProcess) {
     DebuggerManagerThreadImpl.assertIsManagerThread();
     Type type = getType();
     if(type != null && myRenderer != null && myRenderer.isApplicable(type)) {
       return myRenderer;
     }

     myAutoRenderer = debugProcess.getAutoRenderer(this);
     return myAutoRenderer;
   }

   public void setRenderer(NodeRenderer renderer) {
     DebuggerManagerThreadImpl.assertIsManagerThread();
     myRenderer = renderer;
     myAutoRenderer = null;
   }

   //returns expression that evaluates tree to this descriptor
   @Nullable
   public PsiExpression getTreeEvaluation(JavaValue value, DebuggerContextImpl context) throws EvaluateException {
     if(value.getParent() != null) {
       final NodeDescriptorImpl descriptor = value.getParent().getDescriptor();
       final ValueDescriptorImpl vDescriptor = ((ValueDescriptorImpl)descriptor);
       final PsiExpression parentEvaluation = vDescriptor.getTreeEvaluation(value.getParent(), context);

       if (parentEvaluation == null) {
         return null;
       }

       return DebuggerTreeNodeExpression.substituteThis(
         vDescriptor.getRenderer(context.getDebugProcess()).getChildValueExpression(new DebuggerTreeNodeMock(value), context),
         parentEvaluation, vDescriptor.getValue()
       );
     }

     return getDescriptorEvaluation(context);
   }

   private static class DebuggerTreeNodeMock implements DebuggerTreeNode {
     private final JavaValue value;

     public DebuggerTreeNodeMock(JavaValue value) {
       this.value = value;
     }

     @Override
     public DebuggerTreeNode getParent() {
       return new DebuggerTreeNodeMock(value.getParent());
     }

     @Override
     public ValueDescriptorImpl getDescriptor() {
       return value.getDescriptor();
     }

     @Override
     public Project getProject() {
       return value.getProject();
     }

     @Override
     public void setRenderer(NodeRenderer renderer) {
     }
   }

   //returns expression that evaluates descriptor value
   //use 'this' to reference parent node
   //for ex. FieldDescriptorImpl should return
   //this.fieldName
   @Override
   public abstract PsiExpression getDescriptorEvaluation(DebuggerContext context) throws EvaluateException;

   public static String getIdLabel(ObjectReference objRef) {
     StringBuilder buf = StringBuilderSpinAllocator.alloc();
     try {
       final ClassRenderer classRenderer = NodeRendererSettings.getInstance().getClassRenderer();
       final boolean showConcreteType =
         !classRenderer.SHOW_DECLARED_TYPE ||
         (!(objRef instanceof StringReference) && !(objRef instanceof ClassObjectReference) && !isEnumConstant(objRef));
       if (showConcreteType || classRenderer.SHOW_OBJECT_ID) {
         buf.append('{');
         if (showConcreteType) {
           buf.append(classRenderer.renderTypeName(objRef.type().name()));
         }
         if (classRenderer.SHOW_OBJECT_ID) {
           buf.append('@');
           if(ApplicationManager.getApplication().isUnitTestMode()) {
             //noinspection HardCodedStringLiteral
             buf.append("uniqueID");
           }
           else {
             buf.append(objRef.uniqueID());
           }
         }
         buf.append('}');
       }

       if (objRef instanceof ArrayReference) {
         int idx = buf.indexOf("[");
         if(idx >= 0) {
           buf.insert(idx + 1, Integer.toString(((ArrayReference)objRef).length()));
         }
       }

       return buf.toString();
     }
     finally {
       StringBuilderSpinAllocator.dispose(buf);
     }
   }

   private static boolean isEnumConstant(final ObjectReference objRef) {
     final Type type = objRef.type();
     return type instanceof ClassType && ((ClassType)type).isEnum();
   }

   public boolean canSetValue() {
     return myValueReady && !myIsSynthetic && isLvalue();
   }

   public String getValueLabel() {
     return myValueLabel;
   }

   public String getValueText() {
     return myValueText;
   }

   //Context is set to null
   @Override
   public void clear() {
     super.clear();
     setValueLabel("");
     myIsExpandable = false;
   }

   @Override
   @Nullable
   public ValueMarkup getMarkup(final DebugProcess debugProcess) {
     final Value value = getValue();
     if (value instanceof ObjectReference) {
       final ObjectReference objRef = (ObjectReference)value;
       final Map<ObjectReference, ValueMarkup> map = getMarkupMap(debugProcess);
       if (map != null) {
         return map.get(objRef);
       }
     }
     return null;
   }

   @Override
   public void setMarkup(final DebugProcess debugProcess, @Nullable final ValueMarkup markup) {
     final Value value = getValue();
     if (value instanceof ObjectReference) {
       final Map<ObjectReference, ValueMarkup> map = getMarkupMap(debugProcess);
       if (map != null) {
         final ObjectReference objRef = (ObjectReference)value;
         if (markup != null) {
           map.put(objRef, markup);
         }
         else {
           map.remove(objRef);
         }
       }
     }
   }

   public boolean canMark() {
     if (!myValueReady) {
       return false;
     }
     return getValue() instanceof ObjectReference;
   }
 }
	/*
	* Copyright 2000-2009 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.debugger.ui.impl.watch;

	import com.intellij.Patches;
	import com.intellij.debugger.DebuggerContext;
	import com.intellij.debugger.engine.*;
	import com.intellij.debugger.engine.evaluation.EvaluateException;
	import com.intellij.debugger.engine.evaluation.EvaluationContextImpl;
	import com.intellij.debugger.engine.events.SuspendContextCommandImpl;
	import com.intellij.debugger.impl.DebuggerContextImpl;
	import com.intellij.debugger.jdi.VirtualMachineProxyImpl;
	import com.intellij.debugger.settings.NodeRendererSettings;
	import com.intellij.debugger.ui.tree.DebuggerTreeNode;
	import com.intellij.debugger.ui.tree.NodeDescriptor;
	import com.intellij.debugger.ui.tree.ValueDescriptor;
	import com.intellij.debugger.ui.tree.render.*;
	import com.intellij.debugger.ui.tree.render.Renderer;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.project.Project;
	import com.intellij.psi.PsiExpression;
	import com.intellij.util.StringBuilderSpinAllocator;
	import com.intellij.util.concurrency.Semaphore;
	import com.intellij.xdebugger.impl.ui.tree.ValueMarkup;
	import com.sun.jdi.*;
	import org.jetbrains.annotations.Nullable;

	import javax.swing.*;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;

	public abstract class ValueDescriptorImpl extends NodeDescriptorImpl implements ValueDescriptor{
	protected final Project myProject;

	NodeRenderer myRenderer = null;

	NodeRenderer myAutoRenderer = null;

	private Value myValue;
	private boolean myValueReady;

	private EvaluateException myValueException;
	protected EvaluationContextImpl myStoredEvaluationContext = null;

	private String myValueText;
	private String myValueLabel;
	@Nullable
	private Icon myValueIcon;

	protected boolean myIsNew = true;
	private boolean myIsDirty = false;
	private boolean myIsLvalue = false;
	private boolean myIsExpandable;

	private boolean myShowIdLabel = true;

	protected ValueDescriptorImpl(Project project, Value value) {
	myProject = project;
	myValue = value;
	myValueReady = true;
	}

	protected ValueDescriptorImpl(Project project) {
	myProject = project;
	}

	private void assertValueReady() {
	if (!myValueReady) {
	LOG.error("Value is not yet calculated for " + getClass());
	}
	}

	@Override
	public boolean isArray() {
	assertValueReady();
	return myValue instanceof ArrayReference;
	}

	public boolean isDirty() {
	assertValueReady();
	return myIsDirty;
	}

	@Override
	public boolean isLvalue() {
	assertValueReady();
	return myIsLvalue;
	}

	@Override
	public boolean isNull() {
	assertValueReady();
	return myValue == null;
	}

	@Override
	public boolean isString() {
	assertValueReady();
	return myValue instanceof StringReference;
	}

	@Override
	public boolean isPrimitive() {
	assertValueReady();
	return myValue instanceof PrimitiveValue;
	}

	public boolean isValueValid() {
	return myValueException == null;
	}

	public boolean isShowIdLabel() {
	return myShowIdLabel;
	}

	public void setShowIdLabel(boolean showIdLabel) {
	myShowIdLabel = showIdLabel;
	}

	@Override
	public Value getValue() {
	// the following code makes sense only if we do not use ObjectReference.enableCollection() / disableCollection()
	// to keep temporary objects
	if (Patches.IBM_JDK_DISABLE_COLLECTION_BUG) {
	final EvaluationContextImpl evalContext = myStoredEvaluationContext;
	if (evalContext != null && !evalContext.getSuspendContext().isResumed() &&
	myValue instanceof ObjectReference && VirtualMachineProxyImpl.isCollected((ObjectReference)myValue)) {

	final Semaphore semaphore = new Semaphore();
	semaphore.down();
	evalContext.getDebugProcess().getManagerThread().invoke(new SuspendContextCommandImpl(evalContext.getSuspendContext()) {
	@Override
	public void contextAction() throws Exception {
	// re-setting the context will cause value recalculation
	try {
	setContext(myStoredEvaluationContext);
	}
	finally {
	semaphore.up();
	}
	}

	@Override
	protected void commandCancelled() {
	semaphore.up();
	}
	});
	semaphore.waitFor();
	}
	}

	assertValueReady();
	return myValue;
	}

	@Override
	public boolean isExpandable() {
	return myIsExpandable;
	}

	public abstract Value calcValue(EvaluationContextImpl evaluationContext) throws EvaluateException;

	@Override
	public final void setContext(EvaluationContextImpl evaluationContext) {
	DebuggerManagerThreadImpl.assertIsManagerThread();
	myStoredEvaluationContext = evaluationContext;
	Value value;
	try {
	value = calcValue(evaluationContext);

	if(!myIsNew) {
	try {
	if (myValue instanceof DoubleValue && Double.isNaN(((DoubleValue)myValue).doubleValue())) {
	myIsDirty = !(value instanceof DoubleValue);
	}
	else if (myValue instanceof FloatValue && Float.isNaN(((FloatValue)myValue).floatValue())) {
	myIsDirty = !(value instanceof FloatValue);
	}
	else {
	myIsDirty = (value == null) ? myValue != null : !value.equals(myValue);
	}
	}
	catch (ObjectCollectedException ignored) {
	myIsDirty = true;
	}
	}
	myValue = value;
	myValueException = null;
	}
	catch (EvaluateException e) {
	myValueException = e;
	setFailed(e);
	myValue = getTargetExceptionWithStackTraceFilled(evaluationContext, e);
	myIsExpandable = false;
	}
	finally {
	myValueReady = true;
	}

	myIsNew = false;
	}

	@Nullable
	private static ObjectReference getTargetExceptionWithStackTraceFilled(final EvaluationContextImpl evaluationContext, EvaluateException ex){
	final ObjectReference exceptionObj = ex.getExceptionFromTargetVM();
	if (exceptionObj != null && evaluationContext != null) {
	try {
	final ReferenceType refType = exceptionObj.referenceType();
	final List<Method> methods = refType.methodsByName("getStackTrace", "()[Ljava/lang/StackTraceElement;");
	if (methods.size() > 0) {
	final DebugProcessImpl process = evaluationContext.getDebugProcess();
	process.invokeMethod(evaluationContext, exceptionObj, methods.get(0), Collections.emptyList());

	// print to console as well

	final Field traceField = refType.fieldByName("stackTrace");
	final Value trace = traceField != null? exceptionObj.getValue(traceField) : null;
	if (trace instanceof ArrayReference) {
	final ArrayReference traceArray = (ArrayReference)trace;
	final Type componentType = ((ArrayType)traceArray.referenceType()).componentType();
	if (componentType instanceof ClassType) {
	process.printToConsole(DebuggerUtils.getValueAsString(evaluationContext, exceptionObj));
	process.printToConsole("\n");
	for (Value stackElement : traceArray.getValues()) {
	process.printToConsole("\tat ");
	process.printToConsole(DebuggerUtils.getValueAsString(evaluationContext, stackElement));
	process.printToConsole("\n");
	}
	}
	}
	}
	}
	catch (EvaluateException ignored) {
	}
	catch (ClassNotLoadedException ignored) {
	}
	catch (Throwable e) {
	LOG.info(e); // catch all exceptions to ensure the method returns gracefully
	}
	}
	return exceptionObj;
	}

	@Override
	public void setAncestor(NodeDescriptor oldDescriptor) {
	super.setAncestor(oldDescriptor);
	myIsNew = false;
	ValueDescriptorImpl other = (ValueDescriptorImpl)oldDescriptor;
	if (other.myValueReady) {
	myValue = other.getValue();
	myValueReady = true;
	}
	}

	protected void setLvalue(boolean value) {
	myIsLvalue = value;
	}

	@Override
	protected String calcRepresentation(EvaluationContextImpl context, DescriptorLabelListener labelListener){
	DebuggerManagerThreadImpl.assertIsManagerThread();

	final NodeRenderer renderer = getRenderer(context.getDebugProcess());

	final EvaluateException valueException = myValueException;
	myIsExpandable = (valueException == null \|\| valueException.getExceptionFromTargetVM() != null) && renderer.isExpandable(getValue(), context, this);

	try {
	setValueIcon(renderer.calcValueIcon(this, context, labelListener));
	}
	catch (EvaluateException e) {
	LOG.info(e);
	setValueIcon(null);
	}

	String label;
	if (valueException == null) {
	try {
	label = renderer.calcLabel(this, context, labelListener);
	}
	catch (EvaluateException e) {
	label = setValueLabelFailed(e);
	}
	}
	else {
	label = setValueLabelFailed(valueException);
	}

	return setValueLabel(label);
	}

	private String getCustomLabel(String label) {
	//translate only strings in quotes
	String customLabel = null;
	if(isShowIdLabel() && myValueReady) {
	final Value value = getValue();
	Renderer lastRenderer = getLastRenderer();
	final EvaluationContextImpl evalContext = myStoredEvaluationContext;
	final String idLabel = evalContext != null && lastRenderer != null && !evalContext.getSuspendContext().isResumed()?
	((NodeRendererImpl)lastRenderer).getIdLabel(value, evalContext.getDebugProcess()) :
	null;
	if(idLabel != null && !label.startsWith(idLabel)) {
	customLabel = idLabel;
	}
	}
	final String originalLabel = label == null ? "null" : label;
	return customLabel == null? originalLabel : customLabel + originalLabel;
	}


	@Override
	public String setValueLabel(String label) {
	myValueText = label;
	final String customLabel = getCustomLabel(label);
	myValueLabel = customLabel;
	return setLabel(calcValueName() + " = " + customLabel);
	}

	@Override
	public String setValueLabelFailed(EvaluateException e) {
	final String label = setFailed(e);
	setValueLabel(label);
	return label;
	}

	@Override
	public Icon setValueIcon(Icon icon) {
	return myValueIcon = icon;
	}

	@Nullable
	public Icon getValueIcon() {
	return myValueIcon;
	}

	public abstract String calcValueName();

	@Override
	public void displayAs(NodeDescriptor descriptor) {
	if (descriptor instanceof ValueDescriptorImpl) {
	ValueDescriptorImpl valueDescriptor = (ValueDescriptorImpl)descriptor;
	myRenderer = valueDescriptor.myRenderer;
	}
	super.displayAs(descriptor);
	}

	public Renderer getLastRenderer() {
	return myRenderer != null ? myRenderer: myAutoRenderer;
	}

	@Nullable
	public Type getType() {
	Value value = getValue();
	return value != null ? value.type() : null;
	}

	public NodeRenderer getRenderer (DebugProcessImpl debugProcess) {
	DebuggerManagerThreadImpl.assertIsManagerThread();
	Type type = getType();
	if(type != null && myRenderer != null && myRenderer.isApplicable(type)) {
	return myRenderer;
	}

	myAutoRenderer = debugProcess.getAutoRenderer(this);
	return myAutoRenderer;
	}

	public void setRenderer(NodeRenderer renderer) {
	DebuggerManagerThreadImpl.assertIsManagerThread();
	myRenderer = renderer;
	myAutoRenderer = null;
	}

	//returns expression that evaluates tree to this descriptor
	@Nullable
	public PsiExpression getTreeEvaluation(JavaValue value, DebuggerContextImpl context) throws EvaluateException {
	if(value.getParent() != null) {
	final NodeDescriptorImpl descriptor = value.getParent().getDescriptor();
	final ValueDescriptorImpl vDescriptor = ((ValueDescriptorImpl)descriptor);
	final PsiExpression parentEvaluation = vDescriptor.getTreeEvaluation(value.getParent(), context);

	if (parentEvaluation == null) {
	return null;
	}

	return DebuggerTreeNodeExpression.substituteThis(
	vDescriptor.getRenderer(context.getDebugProcess()).getChildValueExpression(new DebuggerTreeNodeMock(value), context),
	parentEvaluation, vDescriptor.getValue()
	);
	}

	return getDescriptorEvaluation(context);
	}

	private static class DebuggerTreeNodeMock implements DebuggerTreeNode {
	private final JavaValue value;

	public DebuggerTreeNodeMock(JavaValue value) {
	this.value = value;
	}

	@Override
	public DebuggerTreeNode getParent() {
	return new DebuggerTreeNodeMock(value.getParent());
	}

	@Override
	public ValueDescriptorImpl getDescriptor() {
	return value.getDescriptor();
	}

	@Override
	public Project getProject() {
	return value.getProject();
	}

	@Override
	public void setRenderer(NodeRenderer renderer) {
	}
	}

	//returns expression that evaluates descriptor value
	//use 'this' to reference parent node
	//for ex. FieldDescriptorImpl should return
	//this.fieldName
	@Override
	public abstract PsiExpression getDescriptorEvaluation(DebuggerContext context) throws EvaluateException;

	public static String getIdLabel(ObjectReference objRef) {
	StringBuilder buf = StringBuilderSpinAllocator.alloc();
	try {
	final ClassRenderer classRenderer = NodeRendererSettings.getInstance().getClassRenderer();
	final boolean showConcreteType =
	!classRenderer.SHOW_DECLARED_TYPE \|\|
	(!(objRef instanceof StringReference) && !(objRef instanceof ClassObjectReference) && !isEnumConstant(objRef));
	if (showConcreteType \|\| classRenderer.SHOW_OBJECT_ID) {
	buf.append('{');
	if (showConcreteType) {
	buf.append(classRenderer.renderTypeName(objRef.type().name()));
	}
	if (classRenderer.SHOW_OBJECT_ID) {
	buf.append('@');
	if(ApplicationManager.getApplication().isUnitTestMode()) {
	//noinspection HardCodedStringLiteral
	buf.append("uniqueID");
	}
	else {
	buf.append(objRef.uniqueID());
	}
	}
	buf.append('}');
	}

	if (objRef instanceof ArrayReference) {
	int idx = buf.indexOf("[");
	if(idx >= 0) {
	buf.insert(idx + 1, Integer.toString(((ArrayReference)objRef).length()));
	}
	}

	return buf.toString();
	}
	finally {
	StringBuilderSpinAllocator.dispose(buf);
	}
	}

	private static boolean isEnumConstant(final ObjectReference objRef) {
	final Type type = objRef.type();
	return type instanceof ClassType && ((ClassType)type).isEnum();
	}

	public boolean canSetValue() {
	return myValueReady && !myIsSynthetic && isLvalue();
	}

	public String getValueLabel() {
	return myValueLabel;
	}

	public String getValueText() {
	return myValueText;
	}

	//Context is set to null
	@Override
	public void clear() {
	super.clear();
	setValueLabel("");
	myIsExpandable = false;
	}

	@Override
	@Nullable
	public ValueMarkup getMarkup(final DebugProcess debugProcess) {
	final Value value = getValue();
	if (value instanceof ObjectReference) {
	final ObjectReference objRef = (ObjectReference)value;
	final Map<ObjectReference, ValueMarkup> map = getMarkupMap(debugProcess);
	if (map != null) {
	return map.get(objRef);
	}
	}
	return null;
	}

	@Override
	public void setMarkup(final DebugProcess debugProcess, @Nullable final ValueMarkup markup) {
	final Value value = getValue();
	if (value instanceof ObjectReference) {
	final Map<ObjectReference, ValueMarkup> map = getMarkupMap(debugProcess);
	if (map != null) {
	final ObjectReference objRef = (ObjectReference)value;
	if (markup != null) {
	map.put(objRef, markup);
	}
	else {
	map.remove(objRef);
	}
	}
	}
	}

	public boolean canMark() {
	if (!myValueReady) {
	return false;
	}
	return getValue() instanceof ObjectReference;
	}
	}