code: public void writeExpression(Expression oldExp)
  	{
  		if (oldExp == null)
  		{
  			throw new NullPointerException();
  		}
  		try
  		{
  			// if oldValue exists, no operation
  			Object oldValue = expressionValue(oldExp);
  			if (oldValue == null || get(oldValue) != null)
  			{
  				return;
  			}
  
  			// copy to newExp
  			Expression newExp = (Expression) createNewStatement(oldExp);
  			// relate oldValue to newValue
  			try
  			{
  				oldNewMap.put(oldValue, newExp.getValue());
  			}
  			catch (IndexOutOfBoundsException e)
  			{
  				// container does not have any component, set newVal null
  			}
  
  			// force same state
  			writeObject(oldValue);
  		}
  		catch (Exception e)
  		{
  			listener.exceptionThrown(new Exception("failed to write expression: " + oldExp, e)); //$NON-NLS-1$
  		}
  	}
docs: Write an expression of old objects.
  <p>
  The implementation first check the return value of the expression. If there exists a new version of the object, simply return.
  </p>
  <p>
  A new expression is created using the new versions of the target and the arguments. If any of the old objects do not have its new version yet,
  <code>writeObject()</code> is called to create the new version.
  </p>
  <p>
  The new expression is then executed to obtained a new copy of the old return value.
  </p>
  <p>
  Call <code>writeObject()</code> with the old return value, so that more statements will be executed on its new version to change it into the same state
  as the old value.
  </p>
  
  @param oldExp
  the expression to write. The target, arguments, and return value of the expression are all old objects.