2.4/dev/core/src/com/google/gwt/dev/jjs/impl/CompoundAssignmentNormalizer.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * 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.google.gwt.dev.jjs.impl;

 import com.google.gwt.dev.jjs.InternalCompilerException;
 import com.google.gwt.dev.jjs.ast.Context;
 import com.google.gwt.dev.jjs.ast.JArrayRef;
 import com.google.gwt.dev.jjs.ast.JBinaryOperation;
 import com.google.gwt.dev.jjs.ast.JBinaryOperator;
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JFieldRef;
 import com.google.gwt.dev.jjs.ast.JIntLiteral;
 import com.google.gwt.dev.jjs.ast.JLocal;
 import com.google.gwt.dev.jjs.ast.JLocalRef;
 import com.google.gwt.dev.jjs.ast.JLongLiteral;
 import com.google.gwt.dev.jjs.ast.JModVisitor;
 import com.google.gwt.dev.jjs.ast.JNode;
 import com.google.gwt.dev.jjs.ast.JParameterRef;
 import com.google.gwt.dev.jjs.ast.JPostfixOperation;
 import com.google.gwt.dev.jjs.ast.JPrefixOperation;
 import com.google.gwt.dev.jjs.ast.JPrimitiveType;
 import com.google.gwt.dev.jjs.ast.JThisRef;
 import com.google.gwt.dev.jjs.ast.JUnaryOperator;
 import com.google.gwt.dev.jjs.ast.js.JMultiExpression;

 /**
  * <p>
  * Replace problematic compound assignments with a sequence of simpler
  * operations, all of which are either simple assignments or are non-assigning
  * operations. When doing so, be careful that side effects happen exactly once
  * and that the order of any side effects is preserved. The choice of which
  * assignments to replace is made in subclasses; they must override the three
  * <code>shouldBreakUp()</code> methods.
  * </p>
  *
  * <p>
  * Note that because AST nodes are mutable, they cannot be reused in different
  * parts of the same tree. Instead, the node must be cloned before each
  * insertion into a tree other than the first.
  * </p>
  *
  * <p>
  * If the <code>reuseTemps</code> constructor parameter is set to
  * <code>true</code>, then temps of the correct type will be reused once they
  * become available. To determine when a temp can be reused, the current
  * implementation uses a notion of "temp usage scopes". Every time a temporary
  * variable is allocated, it is recorded in the current temp usage scope. Once
  * the current temp usage scope is exited, all of its temps become available for
  * use for other purposes.
  * </p>
  */
 public abstract class CompoundAssignmentNormalizer {
   /**
    * Breaks apart certain complex assignments.
    */
   private class BreakupAssignOpsVisitor extends TempLocalVisitor {

     /**
      * Replaces side effects in lvalue.
      */
     private class ReplaceSideEffectsInLvalue extends JModVisitor {

       private final JMultiExpression multi;

       ReplaceSideEffectsInLvalue(JMultiExpression multi) {
         this.multi = multi;
       }

       public JMultiExpression getMultiExpr() {
         return multi;
       }

       @Override
       public boolean visit(JArrayRef x, Context ctx) {
         JExpression newInstance = possiblyReplace(x.getInstance());
         JExpression newIndexExpr = possiblyReplace(x.getIndexExpr());
         if (newInstance != x.getInstance() || newIndexExpr != x.getIndexExpr()) {
           JArrayRef newExpr = new JArrayRef(x.getSourceInfo(), newInstance, newIndexExpr);
           ctx.replaceMe(newExpr);
         }
         return false;
       }

       @Override
       public boolean visit(JFieldRef x, Context ctx) {
         if (x.getInstance() != null) {
           JExpression newInstance = possiblyReplace(x.getInstance());
           if (newInstance != x.getInstance()) {
             JFieldRef newExpr =
                 new JFieldRef(x.getSourceInfo(), newInstance, x.getField(), x.getEnclosingType());
             ctx.replaceMe(newExpr);
           }
         }
         return false;
       }

       @Override
       public boolean visit(JLocalRef x, Context ctx) {
         return false;
       }

       @Override
       public boolean visit(JParameterRef x, Context ctx) {
         return false;
       }

       @Override
       public boolean visit(JThisRef x, Context ctx) {
         return false;
       }

       private JExpression possiblyReplace(JExpression x) {
         if (!x.hasSideEffects()) {
           return x;
         }

         // Create a temp local
         JLocal tempLocal = createTempLocal(x.getSourceInfo(), x.getType());

         // Create an assignment for this temp and add it to multi.
         JLocalRef tempRef = new JLocalRef(x.getSourceInfo(), tempLocal);
         JBinaryOperation asg =
             new JBinaryOperation(x.getSourceInfo(), x.getType(), JBinaryOperator.ASG, tempRef, x);
         multi.exprs.add(asg);
         // Update me with the temp
         return cloner.cloneExpression(tempRef);
       }
     }

     @Override
     public void endVisit(JBinaryOperation x, Context ctx) {
       JBinaryOperator op = x.getOp();
       if (op.getNonAssignmentOf() == null) {
         return;
       }
       if (!shouldBreakUp(x)) {
         return;
       }

       /*
        * Convert to an assignment and binary operation. Since the left hand size
        * must be computed twice, we have to replace any left-hand side
        * expressions that could have side effects with temporaries, so that they
        * are only run once.
        */
       ReplaceSideEffectsInLvalue replacer =
           new ReplaceSideEffectsInLvalue(new JMultiExpression(x.getSourceInfo()));
       JExpression newLhs = replacer.accept(x.getLhs());

       JExpression operation =
           new JBinaryOperation(x.getSourceInfo(), newLhs.getType(), op.getNonAssignmentOf(),
               newLhs, x.getRhs());
       operation = modifyResultOperation((JBinaryOperation) operation);

       // newLhs is cloned below because it was used in operation
       JBinaryOperation asg =
           new JBinaryOperation(x.getSourceInfo(), newLhs.getType(), JBinaryOperator.ASG, cloner
               .cloneExpression(newLhs), operation);

       JMultiExpression multiExpr = replacer.getMultiExpr();
       if (multiExpr.exprs.isEmpty()) {
         // just use the split assignment expression
         ctx.replaceMe(asg);
       } else {
         // add the assignment as the last item in the multi
         multiExpr.exprs.add(asg);
         ctx.replaceMe(multiExpr);
       }
     }

     @Override
     public void endVisit(JPostfixOperation x, Context ctx) {
       JUnaryOperator op = x.getOp();
       if (!op.isModifying()) {
         return;
       }
       if (!shouldBreakUp(x)) {
         return;
       }

       // Convert into a comma operation, such as:
       // (t = x, x += 1, t)

       // First, replace the arg with a non-side-effect causing one.
       JMultiExpression multi = new JMultiExpression(x.getSourceInfo());
       ReplaceSideEffectsInLvalue replacer = new ReplaceSideEffectsInLvalue(multi);
       JExpression newArg = replacer.accept(x.getArg());

       JExpression expressionReturn = expressionToReturn(newArg);

       // Now generate the appropriate expressions.
       JLocal tempLocal = createTempLocal(x.getSourceInfo(), expressionReturn.getType());

       // t = x
       JLocalRef tempRef = new JLocalRef(x.getSourceInfo(), tempLocal);
       JBinaryOperation asg =
           new JBinaryOperation(x.getSourceInfo(), x.getType(), JBinaryOperator.ASG, tempRef,
               expressionReturn);
       multi.exprs.add(asg);

       // x += 1
       asg = createAsgOpFromUnary(newArg, op);
       // Break the resulting asg op before adding to multi.
       multi.exprs.add(accept(asg));

       // t
       tempRef = new JLocalRef(x.getSourceInfo(), tempLocal);
       multi.exprs.add(tempRef);

       ctx.replaceMe(multi);
     }

     @Override
     public void endVisit(JPrefixOperation x, Context ctx) {
       JUnaryOperator op = x.getOp();
       if (!op.isModifying()) {
         return;
       }
       if (!shouldBreakUp(x)) {
         return;
       }

       // Convert into the equivalent binary assignment operation, such as:
       // x += 1
       JBinaryOperation asg = createAsgOpFromUnary(x.getArg(), op);

       // Visit the result to break it up even more.
       ctx.replaceMe(accept(asg));
     }

     private JBinaryOperation createAsgOpFromUnary(JExpression arg, JUnaryOperator op) {
       JBinaryOperator newOp;
       if (op == JUnaryOperator.INC) {
         newOp = JBinaryOperator.ASG_ADD;
       } else if (op == JUnaryOperator.DEC) {
         newOp = JBinaryOperator.ASG_SUB;
       } else {
         throw new InternalCompilerException("Unexpected modifying unary operator: "
             + String.valueOf(op.getSymbol()));
       }

       JExpression one;
       if (arg.getType() == JPrimitiveType.LONG) {
         // use an explicit long, so that LongEmulationNormalizer does not get
         // confused
         one = JLongLiteral.get(1);
       } else {
         // int is safe to add to all other types
         one = JIntLiteral.get(1);
       }
       // arg is cloned below because the caller is allowed to use it somewhere
       JBinaryOperation asg =
           new JBinaryOperation(arg.getSourceInfo(), arg.getType(), newOp, cloner
               .cloneExpression(arg), one);
       return asg;
     }
   }

   private final CloneExpressionVisitor cloner = new CloneExpressionVisitor();

   public void accept(JNode node) {
     BreakupAssignOpsVisitor breaker = new BreakupAssignOpsVisitor();
     breaker.accept(node);
   }

   /**
    * Decide what expression to return when breaking up a compound assignment of
    * the form <code>lhs op= rhs</code>. By default the <code>lhs</code> is
    * returned.
    */
   protected JExpression expressionToReturn(JExpression lhs) {
     return lhs;
   }

   /**
    * Decide what expression to return when breaking up a compound assignment of
    * the form <code>lhs op= rhs</code>. The breakup creates an expression of the
    * form <code>lhs = lhs op rhs</code>, and the right hand side of the newly
    * created expression is passed to this method.
    */
   protected JExpression modifyResultOperation(JBinaryOperation op) {
     return op;
   }

   protected abstract boolean shouldBreakUp(JBinaryOperation x);

   protected abstract boolean shouldBreakUp(JPostfixOperation x);

   protected abstract boolean shouldBreakUp(JPrefixOperation x);
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* 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.google.gwt.dev.jjs.impl;

	import com.google.gwt.dev.jjs.InternalCompilerException;
	import com.google.gwt.dev.jjs.ast.Context;
	import com.google.gwt.dev.jjs.ast.JArrayRef;
	import com.google.gwt.dev.jjs.ast.JBinaryOperation;
	import com.google.gwt.dev.jjs.ast.JBinaryOperator;
	import com.google.gwt.dev.jjs.ast.JExpression;
	import com.google.gwt.dev.jjs.ast.JFieldRef;
	import com.google.gwt.dev.jjs.ast.JIntLiteral;
	import com.google.gwt.dev.jjs.ast.JLocal;
	import com.google.gwt.dev.jjs.ast.JLocalRef;
	import com.google.gwt.dev.jjs.ast.JLongLiteral;
	import com.google.gwt.dev.jjs.ast.JModVisitor;
	import com.google.gwt.dev.jjs.ast.JNode;
	import com.google.gwt.dev.jjs.ast.JParameterRef;
	import com.google.gwt.dev.jjs.ast.JPostfixOperation;
	import com.google.gwt.dev.jjs.ast.JPrefixOperation;
	import com.google.gwt.dev.jjs.ast.JPrimitiveType;
	import com.google.gwt.dev.jjs.ast.JThisRef;
	import com.google.gwt.dev.jjs.ast.JUnaryOperator;
	import com.google.gwt.dev.jjs.ast.js.JMultiExpression;

	/**
	* <p>
	* Replace problematic compound assignments with a sequence of simpler
	* operations, all of which are either simple assignments or are non-assigning
	* operations. When doing so, be careful that side effects happen exactly once
	* and that the order of any side effects is preserved. The choice of which
	* assignments to replace is made in subclasses; they must override the three
	* <code>shouldBreakUp()</code> methods.
	* </p>
	*
	* <p>
	* Note that because AST nodes are mutable, they cannot be reused in different
	* parts of the same tree. Instead, the node must be cloned before each
	* insertion into a tree other than the first.
	* </p>
	*
	* <p>
	* If the <code>reuseTemps</code> constructor parameter is set to
	* <code>true</code>, then temps of the correct type will be reused once they
	* become available. To determine when a temp can be reused, the current
	* implementation uses a notion of "temp usage scopes". Every time a temporary
	* variable is allocated, it is recorded in the current temp usage scope. Once
	* the current temp usage scope is exited, all of its temps become available for
	* use for other purposes.
	* </p>
	*/
	public abstract class CompoundAssignmentNormalizer {
	/**
	* Breaks apart certain complex assignments.
	*/
	private class BreakupAssignOpsVisitor extends TempLocalVisitor {

	/**
	* Replaces side effects in lvalue.
	*/
	private class ReplaceSideEffectsInLvalue extends JModVisitor {

	private final JMultiExpression multi;

	ReplaceSideEffectsInLvalue(JMultiExpression multi) {
	this.multi = multi;
	}

	public JMultiExpression getMultiExpr() {
	return multi;
	}

	@Override
	public boolean visit(JArrayRef x, Context ctx) {
	JExpression newInstance = possiblyReplace(x.getInstance());
	JExpression newIndexExpr = possiblyReplace(x.getIndexExpr());
	if (newInstance != x.getInstance() \|\| newIndexExpr != x.getIndexExpr()) {
	JArrayRef newExpr = new JArrayRef(x.getSourceInfo(), newInstance, newIndexExpr);
	ctx.replaceMe(newExpr);
	}
	return false;
	}

	@Override
	public boolean visit(JFieldRef x, Context ctx) {
	if (x.getInstance() != null) {
	JExpression newInstance = possiblyReplace(x.getInstance());
	if (newInstance != x.getInstance()) {
	JFieldRef newExpr =
	new JFieldRef(x.getSourceInfo(), newInstance, x.getField(), x.getEnclosingType());
	ctx.replaceMe(newExpr);
	}
	}
	return false;
	}

	@Override
	public boolean visit(JLocalRef x, Context ctx) {
	return false;
	}

	@Override
	public boolean visit(JParameterRef x, Context ctx) {
	return false;
	}

	@Override
	public boolean visit(JThisRef x, Context ctx) {
	return false;
	}

	private JExpression possiblyReplace(JExpression x) {
	if (!x.hasSideEffects()) {
	return x;
	}

	// Create a temp local
	JLocal tempLocal = createTempLocal(x.getSourceInfo(), x.getType());

	// Create an assignment for this temp and add it to multi.
	JLocalRef tempRef = new JLocalRef(x.getSourceInfo(), tempLocal);
	JBinaryOperation asg =
	new JBinaryOperation(x.getSourceInfo(), x.getType(), JBinaryOperator.ASG, tempRef, x);
	multi.exprs.add(asg);
	// Update me with the temp
	return cloner.cloneExpression(tempRef);
	}
	}

	@Override
	public void endVisit(JBinaryOperation x, Context ctx) {
	JBinaryOperator op = x.getOp();
	if (op.getNonAssignmentOf() == null) {
	return;
	}
	if (!shouldBreakUp(x)) {
	return;
	}

	/*
	* Convert to an assignment and binary operation. Since the left hand size
	* must be computed twice, we have to replace any left-hand side
	* expressions that could have side effects with temporaries, so that they
	* are only run once.
	*/
	ReplaceSideEffectsInLvalue replacer =
	new ReplaceSideEffectsInLvalue(new JMultiExpression(x.getSourceInfo()));
	JExpression newLhs = replacer.accept(x.getLhs());

	JExpression operation =
	new JBinaryOperation(x.getSourceInfo(), newLhs.getType(), op.getNonAssignmentOf(),
	newLhs, x.getRhs());
	operation = modifyResultOperation((JBinaryOperation) operation);

	// newLhs is cloned below because it was used in operation
	JBinaryOperation asg =
	new JBinaryOperation(x.getSourceInfo(), newLhs.getType(), JBinaryOperator.ASG, cloner
	.cloneExpression(newLhs), operation);

	JMultiExpression multiExpr = replacer.getMultiExpr();
	if (multiExpr.exprs.isEmpty()) {
	// just use the split assignment expression
	ctx.replaceMe(asg);
	} else {
	// add the assignment as the last item in the multi
	multiExpr.exprs.add(asg);
	ctx.replaceMe(multiExpr);
	}
	}

	@Override
	public void endVisit(JPostfixOperation x, Context ctx) {
	JUnaryOperator op = x.getOp();
	if (!op.isModifying()) {
	return;
	}
	if (!shouldBreakUp(x)) {
	return;
	}

	// Convert into a comma operation, such as:
	// (t = x, x += 1, t)

	// First, replace the arg with a non-side-effect causing one.
	JMultiExpression multi = new JMultiExpression(x.getSourceInfo());
	ReplaceSideEffectsInLvalue replacer = new ReplaceSideEffectsInLvalue(multi);
	JExpression newArg = replacer.accept(x.getArg());

	JExpression expressionReturn = expressionToReturn(newArg);

	// Now generate the appropriate expressions.
	JLocal tempLocal = createTempLocal(x.getSourceInfo(), expressionReturn.getType());

	// t = x
	JLocalRef tempRef = new JLocalRef(x.getSourceInfo(), tempLocal);
	JBinaryOperation asg =
	new JBinaryOperation(x.getSourceInfo(), x.getType(), JBinaryOperator.ASG, tempRef,
	expressionReturn);
	multi.exprs.add(asg);

	// x += 1
	asg = createAsgOpFromUnary(newArg, op);
	// Break the resulting asg op before adding to multi.
	multi.exprs.add(accept(asg));

	// t
	tempRef = new JLocalRef(x.getSourceInfo(), tempLocal);
	multi.exprs.add(tempRef);

	ctx.replaceMe(multi);
	}

	@Override
	public void endVisit(JPrefixOperation x, Context ctx) {
	JUnaryOperator op = x.getOp();
	if (!op.isModifying()) {
	return;
	}
	if (!shouldBreakUp(x)) {
	return;
	}

	// Convert into the equivalent binary assignment operation, such as:
	// x += 1
	JBinaryOperation asg = createAsgOpFromUnary(x.getArg(), op);

	// Visit the result to break it up even more.
	ctx.replaceMe(accept(asg));
	}

	private JBinaryOperation createAsgOpFromUnary(JExpression arg, JUnaryOperator op) {
	JBinaryOperator newOp;
	if (op == JUnaryOperator.INC) {
	newOp = JBinaryOperator.ASG_ADD;
	} else if (op == JUnaryOperator.DEC) {
	newOp = JBinaryOperator.ASG_SUB;
	} else {
	throw new InternalCompilerException("Unexpected modifying unary operator: "
	+ String.valueOf(op.getSymbol()));
	}

	JExpression one;
	if (arg.getType() == JPrimitiveType.LONG) {
	// use an explicit long, so that LongEmulationNormalizer does not get
	// confused
	one = JLongLiteral.get(1);
	} else {
	// int is safe to add to all other types
	one = JIntLiteral.get(1);
	}
	// arg is cloned below because the caller is allowed to use it somewhere
	JBinaryOperation asg =
	new JBinaryOperation(arg.getSourceInfo(), arg.getType(), newOp, cloner
	.cloneExpression(arg), one);
	return asg;
	}
	}

	private final CloneExpressionVisitor cloner = new CloneExpressionVisitor();

	public void accept(JNode node) {
	BreakupAssignOpsVisitor breaker = new BreakupAssignOpsVisitor();
	breaker.accept(node);
	}

	/**
	* Decide what expression to return when breaking up a compound assignment of
	* the form <code>lhs op= rhs</code>. By default the <code>lhs</code> is
	* returned.
	*/
	protected JExpression expressionToReturn(JExpression lhs) {
	return lhs;
	}

	/**
	* Decide what expression to return when breaking up a compound assignment of
	* the form <code>lhs op= rhs</code>. The breakup creates an expression of the
	* form <code>lhs = lhs op rhs</code>, and the right hand side of the newly
	* created expression is passed to this method.
	*/
	protected JExpression modifyResultOperation(JBinaryOperation op) {
	return op;
	}

	protected abstract boolean shouldBreakUp(JBinaryOperation x);

	protected abstract boolean shouldBreakUp(JPostfixOperation x);

	protected abstract boolean shouldBreakUp(JPrefixOperation x);
	}