dev/core/test/com/google/gwt/dev/jjs/impl/OptimizerTestBase.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.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.jjs.SourceInfo;
 import com.google.gwt.dev.jjs.ast.Context;
 import com.google.gwt.dev.jjs.ast.JBinaryOperation;
 import com.google.gwt.dev.jjs.ast.JBinaryOperator;
 import com.google.gwt.dev.jjs.ast.JDeclaredType;
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JExpressionStatement;
 import com.google.gwt.dev.jjs.ast.JField;
 import com.google.gwt.dev.jjs.ast.JFieldRef;
 import com.google.gwt.dev.jjs.ast.JLocal;
 import com.google.gwt.dev.jjs.ast.JLocalRef;
 import com.google.gwt.dev.jjs.ast.JMethod;
 import com.google.gwt.dev.jjs.ast.JMethodBody;
 import com.google.gwt.dev.jjs.ast.JMethodCall;
 import com.google.gwt.dev.jjs.ast.JModVisitor;
 import com.google.gwt.dev.jjs.ast.JNode;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.jjs.ast.JReferenceType;
 import com.google.gwt.dev.jjs.ast.JReturnStatement;
 import com.google.gwt.dev.jjs.ast.JStatement;
 import com.google.gwt.dev.jjs.ast.JType;
 import com.google.gwt.dev.jjs.ast.JVisitor;
 import com.google.gwt.dev.jjs.ast.js.JMultiExpression;
 import com.google.gwt.dev.util.UnitTestTreeLogger;
 import com.google.gwt.thirdparty.guava.common.base.Function;
 import com.google.gwt.thirdparty.guava.common.base.Joiner;
 import com.google.gwt.thirdparty.guava.common.base.Preconditions;
 import com.google.gwt.thirdparty.guava.common.collect.FluentIterable;
 import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet;
 import com.google.gwt.thirdparty.guava.common.collect.Lists;
 import com.google.gwt.thirdparty.guava.common.collect.Sets;

 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 import java.util.regex.Pattern;

 import javax.annotation.Nullable;

 /**
  * Test case for testing Jjs optimizers. Adds a convenient Result class.
  */
 public abstract class OptimizerTestBase extends JJSTestBase {
   protected boolean runDeadCodeElimination = false;

   /**
    * Holds the result of optimization to compare against expected results.
    */
   protected final class Result {
     private final String returnType;
     private final String originalCode;
     private final boolean madeChanges;
     private final JProgram optimizedProgram;
     private final String methodName;

     public Result(JProgram optimizedProgram, String returnType,
         String methodName, String originalCode, boolean madeChanges) {
       this.optimizedProgram = optimizedProgram;
       this.returnType = returnType;
       this.methodName = methodName;
       this.originalCode = originalCode;
       this.madeChanges = madeChanges;
     }

     public void classHasMethods(String className, List<String> expectedMethodSnippets) {
       final JDeclaredType targetClass = findClass(className);

       Set<String> actualMethodSignatures = Sets.newHashSet();
       for (JMethod method : targetClass.getMethods()) {
         actualMethodSignatures.add(method.toString());
       }

       ImmutableSet<String> expectedMethodSignatures = FluentIterable.from(expectedMethodSnippets)
           .transform(new Function<String, String>() {
             @Nullable
             @Override
             public String apply(String unqualifiedMethodSignature) {
               return targetClass.getName() + "." + unqualifiedMethodSignature;
             }
           }).toSet();
       assertContainsAll(
           expectedMethodSignatures, actualMethodSignatures);
     }

     /**
      * Check whether the resulting is equivalent to {@code expected}.<p>
      *
      * Caveat: {@code expected} needs to be syntactically and type correct (as it will be compiled).
      * Normalizer passes for the most part are not expected to produce type correct transformations
      * as at the end the will be translated into an untyped language.
      * In some cases the test might be able to use this function even if it is testing a pass
      * that does not produce type correct program by replacing some standard mocked resources
      * (tweaking method parameter and return types).
      */
     public void into(String... expected) throws UnableToCompleteException {
       // We can't compile expected code into non-main method.
       Preconditions.checkState(methodName.equals(MAIN_METHOD_NAME));
       JProgram program = compileSnippet(returnType, Joiner.on("\n").join(expected), true);
       String expectedSource =
         OptimizerTestBase.findMethod(program, methodName).getBody().toSource();
       String actualSource =
         OptimizerTestBase.findMethod(optimizedProgram, methodName)
             .getBody().toSource();
       assertEquals(originalCode, expectedSource, actualSource);
     }

     public void intoString(String... expected) {
       String expectedSource = Joiner.on("\n").join(expected);
       String actualSource =
         OptimizerTestBase.findMethod(optimizedProgram, methodName)
             .getBody().toSource();

       // Trim surrounding {} and unindent body once
       assertTrue(actualSource.startsWith("{"));
       assertTrue(actualSource.endsWith("}"));
       actualSource = actualSource.substring(1, actualSource.length() - 2).trim();
       actualSource = Pattern.compile("^  ", Pattern.MULTILINE)
           .matcher(actualSource).replaceAll("");

       assertEquals(originalCode, expectedSource, actualSource);
     }

     public void noChange() {
       assertFalse(madeChanges);
     }

     public JMethod findMethod(String methodName) {
       return OptimizerTestBase.findMethod(optimizedProgram, methodName);
     }

     public JField findField(String fieldName) {
       return OptimizerTestBase.findField(optimizedProgram,
           "EntryPoint." + fieldName);
     }

     public JDeclaredType findClass(String className) {
       return OptimizerTestBase.findDeclaredType(optimizedProgram, className);
     }

     public JProgram getOptimizedProgram() {
       return optimizedProgram;
     }
   }

   /**
    * Asserts that there {@code method} calls all and only {@code expectedTargets}.
    */
   protected static void assertCallsAndOnlyCalls(JMethod method, JMethod... expectedTargets) {
     final Set<JMethod> actualTargets = Sets.newHashSet();
     new JVisitor() {
       @Override
       public void endVisit(JMethodCall x, Context ctx) {
         actualTargets.add(x.getTarget());
       }
     }.accept(method);
     assertEquals(ImmutableSet.copyOf(expectedTargets), actualTargets);
   }

   /**
    * Asserts that the compile fails with {@code expectedErrors}.
    */
   public final void assertCompileFails(String code, String... expectedErrors) {
     assert expectedErrors != null : "Failed compiles must specify error messages.";
     UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
     builder.setLowestLogLevel(TreeLogger.ERROR);
     for (String expectedError : expectedErrors) {
       builder.expectError(expectedError, null);
     }
     UnitTestTreeLogger errorLogger = builder.createLogger();

     try {
       optimize(errorLogger, "void", code);
       fail("Compile should have failed but succeeded.");
     } catch (Exception e) {
       if (!(e.getCause() instanceof UnableToCompleteException)
           && !(e instanceof UnableToCompleteException)) {
         e.printStackTrace();
         fail();
       }
     }
     errorLogger.assertCorrectLogEntries();
   }

   /**
    * Asserts that the compile succeeds with {@code expectedWarnings}.
    */
   public final Result assertCompileSucceeds(String code,
       String... expectedWarnings) throws UnableToCompleteException {
     UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
     builder.setLowestLogLevel(TreeLogger.WARN);
     if (expectedWarnings != null) {
       for (String expectedWarning : expectedWarnings) {
         builder.expectWarn(expectedWarning, null);
       }
     }
     UnitTestTreeLogger errorLogger = builder.createLogger();

     try {
       return optimize(errorLogger, "void", code);
     } catch (UnableToCompleteException e) {
       fail("Compile failed");
     } finally {
       errorLogger.assertCorrectLogEntries();
     }
     return null;
   }

   /**
    * Asserts that there {@code method} only calls {@code forwardsToMethod}.
    */
   protected static void assertForwardsTo(JMethod method, JMethod forwardsToMethod) {
     assertCallsAndOnlyCalls(method, forwardsToMethod);
   }

   protected static void assertOverrides(
       Result result, String fullMethodSignature, String... overriddenMethodSignatures) {
     assertEquals(ImmutableSet.copyOf(overriddenMethodSignatures),
         findOverrides(result, fullMethodSignature));
   }

   protected static void assertParameterTypes(
       final Result result, String methodName, String... parameterTypeNames) {
     JMethod method = findMethod(result, methodName);
     assertNotNull("Did not find method " + methodName, method);
     assertEquals(parameterTypeNames.length, method.getParams().size());
     JType[] parameterTypes = FluentIterable.from(Arrays.asList(parameterTypeNames))
         .transform(new Function<String, JType>() {
           @Nullable
           @Override
           public JType apply(String typeName) {
             return findType(result, typeName);
           }
         })
         .toArray(JType.class);
     assertParameterTypes(method, parameterTypes);
   }

   protected static <T extends JNode> Collection<T> getNodes(
       final Class<T> expressionClass, JNode inNode, final boolean exactClass) {
     final List<T> result = Lists.newArrayList();
     new JVisitor() {
       @Override
       public boolean visit(JNode x, Context ctx) {
         if (x.getClass() == expressionClass || expressionClass.isInstance(x) && !exactClass) {
           result.add(expressionClass.cast(x));
         }
         return true;
       }

     }.accept(inNode);
     return result;
   }

   protected static void assertReturnType(
       Result result, String methodName, String resultTypeName) {
     JMethod method = findMethod(result, methodName);
     assertNotNull("Did not find method " + methodName, method);
     JDeclaredType resultType = result.findClass(resultTypeName);
     assertNotNull("Did not find class " + resultTypeName, resultType);
     assertEquals(resultType, method.getType().getUnderlyingType());
   }

   protected static JMethod findMethod(Result result, String methodName) {
     int lastDot = methodName.lastIndexOf(".");
     JMethod method = null;
     if (lastDot != -1) {
       String className = methodName.substring(0, lastDot);
       JDeclaredType clazz = result.findClass(className);
       assertNotNull("Did not find class " + className, clazz);
       method = clazz.findMethod(methodName.substring(lastDot + 1), true);
     } else {
       method = result.findMethod(methodName);
     }
     return method;
   }

   protected static ImmutableSet<String> findOverrides(Result result, String fullMethodSignature) {
     final Function<JMethod, String> METHOD_TO_STRING =
         new Function<JMethod, String>() {
           @Nullable
           @Override
           public String apply(JMethod method) {
             return method.toString();
           }
         };
     JMethod method = findMethod(result, fullMethodSignature);
     assertNotNull("Method " + fullMethodSignature + " not found", method);
     assertEquals(fullMethodSignature, method.toString());
     return FluentIterable
         .from(method.getOverriddenMethods())
         .transform(METHOD_TO_STRING)
         .toSet();
   }

   private static JReferenceType findType(Result result, String parameterTypeName) {
     JReferenceType parameterType;
     if (parameterTypeName.equals("null")) {
       parameterType = JReferenceType.NULL_TYPE;
     } else {
       parameterType = result.findClass(parameterTypeName);
     }
     return parameterType;
   }

   /**
    * Makes implicit <code>$clinit()</code> calls explicit to mimic the effect of other
    * optimizations. Otherwise can not test optimizations that involve <code>$clinit</code> calls
    * as they don't appear when compiling small snippets.
    *
    * @param method method to transform to make <code>$clinit</code> calls explicit.
    */
   private void insertImplicitClinitCalls(final JMethod method) {
     // Mimic the method inliner which inserts clinits calls prior to method or field dereference.
     // The actual clinit() calls might be inserted as a result of optimizations: e,g,
     // DeadCodeElimination inserts clinit calls when it removes (some) field accesses or method
     // calls.
     final JMethodBody body = (JMethodBody) method.getBody();

     new JModVisitor() {

       private JMethodCall createClinitCall(SourceInfo sourceInfo, JDeclaredType targetType) {
         JMethod clinit = targetType.getClinitTarget().getClinitMethod();
         assert (JProgram.isClinit(clinit));
         return new JMethodCall(sourceInfo, null, clinit);
       }

       private JMultiExpression createMultiExpressionForInstanceAndClinit(JExpression x) {
         JMultiExpression multi = new JMultiExpression(x.getSourceInfo());

         JMethodCall clinit = null;
         if (x instanceof JMethodCall) {
           JExpression instance = ((JMethodCall) x).getInstance();

           // Any instance expression goes first (this can happen even with statics).
           if (instance != null) {

             multi.addExpressions(instance);
             JLocal var = JProgram.createLocal(instance.getSourceInfo(), "$t", instance.getType(),
                 false, body);

             JLocalRef localRef = var.makeRef(var.getSourceInfo());
             instance = new JBinaryOperation(instance.getSourceInfo(), localRef.getType(),
                 JBinaryOperator.ASG, localRef, instance);
           }
           clinit = createClinitCall(x.getSourceInfo(),
               ((JMethodCall) x).getTarget().getEnclosingType());
         } else if (x instanceof JFieldRef) {
           clinit = createClinitCall(x.getSourceInfo(), ((JFieldRef) x).getEnclosingType());
         }
         // If we need a clinit call, add it first
         if (clinit != null) {
           multi.addExpressions(clinit);
         }
         multi.addExpressions(x);
         return multi;
       }

       @Override
       public void endVisit(JMethodCall x, Context ctx) {
         ctx.replaceMe(createMultiExpressionForInstanceAndClinit(x));
       }

       @Override
       public void endVisit(JFieldRef x, Context ctx) {
         ctx.replaceMe(createMultiExpressionForInstanceAndClinit(x));
       }

     }.accept(method);
   }

   protected final Result optimize(TreeLogger logger, final String returnType,
       final String... codeSnippet) throws UnableToCompleteException {
     return optimizeMethod(logger, MAIN_METHOD_NAME, returnType, codeSnippet);
   }

   protected final Result optimize(final String returnType,
       final String... codeSnippet) {

     UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
     builder.setLowestLogLevel(TreeLogger.WARN);

     try {
       return optimize(null, returnType, codeSnippet);
     } catch (UnableToCompleteException e) {
       fail();
       return null;
     }
   }

   /**
    * Test the effect of an optimization on a JMultiExpression.
    * JMultiExpression can not be constructed from source code at the moment as it is not a valid
    * java source construct.
    *
    * @param addClinitCalls whether to insert the implicit clinit calls. This is necessary because
    *                       clinit() methods are synthetic can not be inserted explicitly as source
    *                       code calls.
    * @param returnType the return type of the JMultiExpression. Must be <code>void</code> or
    *                   compatible with the last expression.
    * @param expressionSnippets source code of the expressions.
    * @return the optimization result.
    * @throws UnableToCompleteException
    */
   protected final Result optimizeExpressions(boolean addClinitCalls, final String returnType,
                                   final String... expressionSnippets)
       throws UnableToCompleteException {

     // TODO(rluble): Not very elegant to require that the snippets be statements instead of
     // expressions.

     assert expressionSnippets.length > 0;

     // Compile as statements
     if (!returnType.equals("void")) {
       expressionSnippets[expressionSnippets.length - 1] =
           "return " + expressionSnippets[expressionSnippets.length - 1];
     }
     String snippet = Joiner.on(";\n").join(expressionSnippets) + ";\n";
     final JProgram program = compileSnippet(returnType, snippet, true);
     JMethod method = findMethod(program, MAIN_METHOD_NAME);
     JMethodBody body = (JMethodBody) method.getBody();
     JMultiExpression multi = new JMultiExpression(body.getSourceInfo());

     // Transform statement sequence into a JMultiExpression
     for (JStatement stmt : body.getStatements()) {

       if (stmt instanceof JExpressionStatement) {
         JExpressionStatement exprStmt = (JExpressionStatement) stmt;
         JExpression expr = exprStmt.getExpr();
         multi.addExpressions(expr);
       } else if (stmt instanceof JReturnStatement) {
         JReturnStatement returnStatement = (JReturnStatement) stmt;
         JExpression expr = returnStatement.getExpr();
         if (expr != null) {
             multi.addExpressions(expr);
         }
       } else {
         assert false : "Not a valid multiexpression";
       }
     }

     // Take care of the return type
     JStatement multiStm =
         returnType.equals("void") ? multi.makeStatement() : multi.makeReturnStatement();

     // Replace the method body
     JMethodBody newBody = new JMethodBody(method.getBody().getSourceInfo());
     newBody.getBlock().addStmt(multiStm);
     method.setBody(newBody);
     newBody.setMethod(method);
     if (addClinitCalls) {
       insertImplicitClinitCalls(method);
     }

     // Finally optimize.
     boolean madeChanges = doOptimizeMethod(TreeLogger.NULL, program, method);
     if (madeChanges && runDeadCodeElimination) {
       DeadCodeElimination.exec(program);
     }

     return new Result(program, returnType, MAIN_METHOD_NAME, snippet, madeChanges);
   }

   protected final Result optimizeMethod(final String methodName,
       final String mainMethodReturnType, final String... mainMethodSnippet)
       throws UnableToCompleteException {
     return optimizeMethod(null, methodName, mainMethodReturnType, mainMethodSnippet);
   }

   protected final Result optimizeMethod(TreeLogger logger, final String methodName,
       final String mainMethodReturnType, final String... mainMethodSnippet)
       throws UnableToCompleteException {
     if (logger == null) {
       logger = this.logger;
     }
     String snippet = Joiner.on("\n").join(mainMethodSnippet);
     JProgram program = compileSnippet(logger, mainMethodReturnType, snippet, true);
     JMethod method = findMethod(program, methodName);
     boolean madeChanges = doOptimizeMethod(logger, program, method);
     if (madeChanges && runDeadCodeElimination) {
       DeadCodeElimination.exec(program);
     }
     return new Result(program, mainMethodReturnType, methodName, snippet, madeChanges);
   }

   protected abstract boolean doOptimizeMethod(TreeLogger logger, JProgram program, JMethod method)
       throws UnableToCompleteException;
 }
	/*
	* 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.core.ext.TreeLogger;
	import com.google.gwt.core.ext.UnableToCompleteException;
	import com.google.gwt.dev.jjs.SourceInfo;
	import com.google.gwt.dev.jjs.ast.Context;
	import com.google.gwt.dev.jjs.ast.JBinaryOperation;
	import com.google.gwt.dev.jjs.ast.JBinaryOperator;
	import com.google.gwt.dev.jjs.ast.JDeclaredType;
	import com.google.gwt.dev.jjs.ast.JExpression;
	import com.google.gwt.dev.jjs.ast.JExpressionStatement;
	import com.google.gwt.dev.jjs.ast.JField;
	import com.google.gwt.dev.jjs.ast.JFieldRef;
	import com.google.gwt.dev.jjs.ast.JLocal;
	import com.google.gwt.dev.jjs.ast.JLocalRef;
	import com.google.gwt.dev.jjs.ast.JMethod;
	import com.google.gwt.dev.jjs.ast.JMethodBody;
	import com.google.gwt.dev.jjs.ast.JMethodCall;
	import com.google.gwt.dev.jjs.ast.JModVisitor;
	import com.google.gwt.dev.jjs.ast.JNode;
	import com.google.gwt.dev.jjs.ast.JProgram;
	import com.google.gwt.dev.jjs.ast.JReferenceType;
	import com.google.gwt.dev.jjs.ast.JReturnStatement;
	import com.google.gwt.dev.jjs.ast.JStatement;
	import com.google.gwt.dev.jjs.ast.JType;
	import com.google.gwt.dev.jjs.ast.JVisitor;
	import com.google.gwt.dev.jjs.ast.js.JMultiExpression;
	import com.google.gwt.dev.util.UnitTestTreeLogger;
	import com.google.gwt.thirdparty.guava.common.base.Function;
	import com.google.gwt.thirdparty.guava.common.base.Joiner;
	import com.google.gwt.thirdparty.guava.common.base.Preconditions;
	import com.google.gwt.thirdparty.guava.common.collect.FluentIterable;
	import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet;
	import com.google.gwt.thirdparty.guava.common.collect.Lists;
	import com.google.gwt.thirdparty.guava.common.collect.Sets;

	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;
	import java.util.Set;
	import java.util.regex.Pattern;

	import javax.annotation.Nullable;

	/**
	* Test case for testing Jjs optimizers. Adds a convenient Result class.
	*/
	public abstract class OptimizerTestBase extends JJSTestBase {
	protected boolean runDeadCodeElimination = false;

	/**
	* Holds the result of optimization to compare against expected results.
	*/
	protected final class Result {
	private final String returnType;
	private final String originalCode;
	private final boolean madeChanges;
	private final JProgram optimizedProgram;
	private final String methodName;

	public Result(JProgram optimizedProgram, String returnType,
	String methodName, String originalCode, boolean madeChanges) {
	this.optimizedProgram = optimizedProgram;
	this.returnType = returnType;
	this.methodName = methodName;
	this.originalCode = originalCode;
	this.madeChanges = madeChanges;
	}

	public void classHasMethods(String className, List<String> expectedMethodSnippets) {
	final JDeclaredType targetClass = findClass(className);

	Set<String> actualMethodSignatures = Sets.newHashSet();
	for (JMethod method : targetClass.getMethods()) {
	actualMethodSignatures.add(method.toString());
	}

	ImmutableSet<String> expectedMethodSignatures = FluentIterable.from(expectedMethodSnippets)
	.transform(new Function<String, String>() {
	@Nullable
	@Override
	public String apply(String unqualifiedMethodSignature) {
	return targetClass.getName() + "." + unqualifiedMethodSignature;
	}
	}).toSet();
	assertContainsAll(
	expectedMethodSignatures, actualMethodSignatures);
	}

	/**
	* Check whether the resulting is equivalent to {@code expected}.<p>
	*
	* Caveat: {@code expected} needs to be syntactically and type correct (as it will be compiled).
	* Normalizer passes for the most part are not expected to produce type correct transformations
	* as at the end the will be translated into an untyped language.
	* In some cases the test might be able to use this function even if it is testing a pass
	* that does not produce type correct program by replacing some standard mocked resources
	* (tweaking method parameter and return types).
	*/
	public void into(String... expected) throws UnableToCompleteException {
	// We can't compile expected code into non-main method.
	Preconditions.checkState(methodName.equals(MAIN_METHOD_NAME));
	JProgram program = compileSnippet(returnType, Joiner.on("\n").join(expected), true);
	String expectedSource =
	OptimizerTestBase.findMethod(program, methodName).getBody().toSource();
	String actualSource =
	OptimizerTestBase.findMethod(optimizedProgram, methodName)
	.getBody().toSource();
	assertEquals(originalCode, expectedSource, actualSource);
	}

	public void intoString(String... expected) {
	String expectedSource = Joiner.on("\n").join(expected);
	String actualSource =
	OptimizerTestBase.findMethod(optimizedProgram, methodName)
	.getBody().toSource();

	// Trim surrounding {} and unindent body once
	assertTrue(actualSource.startsWith("{"));
	assertTrue(actualSource.endsWith("}"));
	actualSource = actualSource.substring(1, actualSource.length() - 2).trim();
	actualSource = Pattern.compile("^ ", Pattern.MULTILINE)
	.matcher(actualSource).replaceAll("");

	assertEquals(originalCode, expectedSource, actualSource);
	}

	public void noChange() {
	assertFalse(madeChanges);
	}

	public JMethod findMethod(String methodName) {
	return OptimizerTestBase.findMethod(optimizedProgram, methodName);
	}

	public JField findField(String fieldName) {
	return OptimizerTestBase.findField(optimizedProgram,
	"EntryPoint." + fieldName);
	}

	public JDeclaredType findClass(String className) {
	return OptimizerTestBase.findDeclaredType(optimizedProgram, className);
	}

	public JProgram getOptimizedProgram() {
	return optimizedProgram;
	}
	}

	/**
	* Asserts that there {@code method} calls all and only {@code expectedTargets}.
	*/
	protected static void assertCallsAndOnlyCalls(JMethod method, JMethod... expectedTargets) {
	final Set<JMethod> actualTargets = Sets.newHashSet();
	new JVisitor() {
	@Override
	public void endVisit(JMethodCall x, Context ctx) {
	actualTargets.add(x.getTarget());
	}
	}.accept(method);
	assertEquals(ImmutableSet.copyOf(expectedTargets), actualTargets);
	}

	/**
	* Asserts that the compile fails with {@code expectedErrors}.
	*/
	public final void assertCompileFails(String code, String... expectedErrors) {
	assert expectedErrors != null : "Failed compiles must specify error messages.";
	UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
	builder.setLowestLogLevel(TreeLogger.ERROR);
	for (String expectedError : expectedErrors) {
	builder.expectError(expectedError, null);
	}
	UnitTestTreeLogger errorLogger = builder.createLogger();

	try {
	optimize(errorLogger, "void", code);
	fail("Compile should have failed but succeeded.");
	} catch (Exception e) {
	if (!(e.getCause() instanceof UnableToCompleteException)
	&& !(e instanceof UnableToCompleteException)) {
	e.printStackTrace();
	fail();
	}
	}
	errorLogger.assertCorrectLogEntries();
	}

	/**
	* Asserts that the compile succeeds with {@code expectedWarnings}.
	*/
	public final Result assertCompileSucceeds(String code,
	String... expectedWarnings) throws UnableToCompleteException {
	UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
	builder.setLowestLogLevel(TreeLogger.WARN);
	if (expectedWarnings != null) {
	for (String expectedWarning : expectedWarnings) {
	builder.expectWarn(expectedWarning, null);
	}
	}
	UnitTestTreeLogger errorLogger = builder.createLogger();

	try {
	return optimize(errorLogger, "void", code);
	} catch (UnableToCompleteException e) {
	fail("Compile failed");
	} finally {
	errorLogger.assertCorrectLogEntries();
	}
	return null;
	}

	/**
	* Asserts that there {@code method} only calls {@code forwardsToMethod}.
	*/
	protected static void assertForwardsTo(JMethod method, JMethod forwardsToMethod) {
	assertCallsAndOnlyCalls(method, forwardsToMethod);
	}

	protected static void assertOverrides(
	Result result, String fullMethodSignature, String... overriddenMethodSignatures) {
	assertEquals(ImmutableSet.copyOf(overriddenMethodSignatures),
	findOverrides(result, fullMethodSignature));
	}

	protected static void assertParameterTypes(
	final Result result, String methodName, String... parameterTypeNames) {
	JMethod method = findMethod(result, methodName);
	assertNotNull("Did not find method " + methodName, method);
	assertEquals(parameterTypeNames.length, method.getParams().size());
	JType[] parameterTypes = FluentIterable.from(Arrays.asList(parameterTypeNames))
	.transform(new Function<String, JType>() {
	@Nullable
	@Override
	public JType apply(String typeName) {
	return findType(result, typeName);
	}
	})
	.toArray(JType.class);
	assertParameterTypes(method, parameterTypes);
	}

	protected static <T extends JNode> Collection<T> getNodes(
	final Class<T> expressionClass, JNode inNode, final boolean exactClass) {
	final List<T> result = Lists.newArrayList();
	new JVisitor() {
	@Override
	public boolean visit(JNode x, Context ctx) {
	if (x.getClass() == expressionClass \|\| expressionClass.isInstance(x) && !exactClass) {
	result.add(expressionClass.cast(x));
	}
	return true;
	}

	}.accept(inNode);
	return result;
	}

	protected static void assertReturnType(
	Result result, String methodName, String resultTypeName) {
	JMethod method = findMethod(result, methodName);
	assertNotNull("Did not find method " + methodName, method);
	JDeclaredType resultType = result.findClass(resultTypeName);
	assertNotNull("Did not find class " + resultTypeName, resultType);
	assertEquals(resultType, method.getType().getUnderlyingType());
	}

	protected static JMethod findMethod(Result result, String methodName) {
	int lastDot = methodName.lastIndexOf(".");
	JMethod method = null;
	if (lastDot != -1) {
	String className = methodName.substring(0, lastDot);
	JDeclaredType clazz = result.findClass(className);
	assertNotNull("Did not find class " + className, clazz);
	method = clazz.findMethod(methodName.substring(lastDot + 1), true);
	} else {
	method = result.findMethod(methodName);
	}
	return method;
	}

	protected static ImmutableSet<String> findOverrides(Result result, String fullMethodSignature) {
	final Function<JMethod, String> METHOD_TO_STRING =
	new Function<JMethod, String>() {
	@Nullable
	@Override
	public String apply(JMethod method) {
	return method.toString();
	}
	};
	JMethod method = findMethod(result, fullMethodSignature);
	assertNotNull("Method " + fullMethodSignature + " not found", method);
	assertEquals(fullMethodSignature, method.toString());
	return FluentIterable
	.from(method.getOverriddenMethods())
	.transform(METHOD_TO_STRING)
	.toSet();
	}

	private static JReferenceType findType(Result result, String parameterTypeName) {
	JReferenceType parameterType;
	if (parameterTypeName.equals("null")) {
	parameterType = JReferenceType.NULL_TYPE;
	} else {
	parameterType = result.findClass(parameterTypeName);
	}
	return parameterType;
	}

	/**
	* Makes implicit <code>$clinit()</code> calls explicit to mimic the effect of other
	* optimizations. Otherwise can not test optimizations that involve <code>$clinit</code> calls
	* as they don't appear when compiling small snippets.
	*
	* @param method method to transform to make <code>$clinit</code> calls explicit.
	*/
	private void insertImplicitClinitCalls(final JMethod method) {
	// Mimic the method inliner which inserts clinits calls prior to method or field dereference.
	// The actual clinit() calls might be inserted as a result of optimizations: e,g,
	// DeadCodeElimination inserts clinit calls when it removes (some) field accesses or method
	// calls.
	final JMethodBody body = (JMethodBody) method.getBody();

	new JModVisitor() {

	private JMethodCall createClinitCall(SourceInfo sourceInfo, JDeclaredType targetType) {
	JMethod clinit = targetType.getClinitTarget().getClinitMethod();
	assert (JProgram.isClinit(clinit));
	return new JMethodCall(sourceInfo, null, clinit);
	}

	private JMultiExpression createMultiExpressionForInstanceAndClinit(JExpression x) {
	JMultiExpression multi = new JMultiExpression(x.getSourceInfo());

	JMethodCall clinit = null;
	if (x instanceof JMethodCall) {
	JExpression instance = ((JMethodCall) x).getInstance();

	// Any instance expression goes first (this can happen even with statics).
	if (instance != null) {

	multi.addExpressions(instance);
	JLocal var = JProgram.createLocal(instance.getSourceInfo(), "$t", instance.getType(),
	false, body);

	JLocalRef localRef = var.makeRef(var.getSourceInfo());
	instance = new JBinaryOperation(instance.getSourceInfo(), localRef.getType(),
	JBinaryOperator.ASG, localRef, instance);
	}
	clinit = createClinitCall(x.getSourceInfo(),
	((JMethodCall) x).getTarget().getEnclosingType());
	} else if (x instanceof JFieldRef) {
	clinit = createClinitCall(x.getSourceInfo(), ((JFieldRef) x).getEnclosingType());
	}
	// If we need a clinit call, add it first
	if (clinit != null) {
	multi.addExpressions(clinit);
	}
	multi.addExpressions(x);
	return multi;
	}

	@Override
	public void endVisit(JMethodCall x, Context ctx) {
	ctx.replaceMe(createMultiExpressionForInstanceAndClinit(x));
	}

	@Override
	public void endVisit(JFieldRef x, Context ctx) {
	ctx.replaceMe(createMultiExpressionForInstanceAndClinit(x));
	}

	}.accept(method);
	}

	protected final Result optimize(TreeLogger logger, final String returnType,
	final String... codeSnippet) throws UnableToCompleteException {
	return optimizeMethod(logger, MAIN_METHOD_NAME, returnType, codeSnippet);
	}

	protected final Result optimize(final String returnType,
	final String... codeSnippet) {

	UnitTestTreeLogger.Builder builder = new UnitTestTreeLogger.Builder();
	builder.setLowestLogLevel(TreeLogger.WARN);

	try {
	return optimize(null, returnType, codeSnippet);
	} catch (UnableToCompleteException e) {
	fail();
	return null;
	}
	}

	/**
	* Test the effect of an optimization on a JMultiExpression.
	* JMultiExpression can not be constructed from source code at the moment as it is not a valid
	* java source construct.
	*
	* @param addClinitCalls whether to insert the implicit clinit calls. This is necessary because
	* clinit() methods are synthetic can not be inserted explicitly as source
	* code calls.
	* @param returnType the return type of the JMultiExpression. Must be <code>void</code> or
	* compatible with the last expression.
	* @param expressionSnippets source code of the expressions.
	* @return the optimization result.
	* @throws UnableToCompleteException
	*/
	protected final Result optimizeExpressions(boolean addClinitCalls, final String returnType,
	final String... expressionSnippets)
	throws UnableToCompleteException {

	// TODO(rluble): Not very elegant to require that the snippets be statements instead of
	// expressions.

	assert expressionSnippets.length > 0;

	// Compile as statements
	if (!returnType.equals("void")) {
	expressionSnippets[expressionSnippets.length - 1] =
	"return " + expressionSnippets[expressionSnippets.length - 1];
	}
	String snippet = Joiner.on(";\n").join(expressionSnippets) + ";\n";
	final JProgram program = compileSnippet(returnType, snippet, true);
	JMethod method = findMethod(program, MAIN_METHOD_NAME);
	JMethodBody body = (JMethodBody) method.getBody();
	JMultiExpression multi = new JMultiExpression(body.getSourceInfo());

	// Transform statement sequence into a JMultiExpression
	for (JStatement stmt : body.getStatements()) {

	if (stmt instanceof JExpressionStatement) {
	JExpressionStatement exprStmt = (JExpressionStatement) stmt;
	JExpression expr = exprStmt.getExpr();
	multi.addExpressions(expr);
	} else if (stmt instanceof JReturnStatement) {
	JReturnStatement returnStatement = (JReturnStatement) stmt;
	JExpression expr = returnStatement.getExpr();
	if (expr != null) {
	multi.addExpressions(expr);
	}
	} else {
	assert false : "Not a valid multiexpression";
	}
	}

	// Take care of the return type
	JStatement multiStm =
	returnType.equals("void") ? multi.makeStatement() : multi.makeReturnStatement();

	// Replace the method body
	JMethodBody newBody = new JMethodBody(method.getBody().getSourceInfo());
	newBody.getBlock().addStmt(multiStm);
	method.setBody(newBody);
	newBody.setMethod(method);
	if (addClinitCalls) {
	insertImplicitClinitCalls(method);
	}

	// Finally optimize.
	boolean madeChanges = doOptimizeMethod(TreeLogger.NULL, program, method);
	if (madeChanges && runDeadCodeElimination) {
	DeadCodeElimination.exec(program);
	}

	return new Result(program, returnType, MAIN_METHOD_NAME, snippet, madeChanges);
	}

	protected final Result optimizeMethod(final String methodName,
	final String mainMethodReturnType, final String... mainMethodSnippet)
	throws UnableToCompleteException {
	return optimizeMethod(null, methodName, mainMethodReturnType, mainMethodSnippet);
	}

	protected final Result optimizeMethod(TreeLogger logger, final String methodName,
	final String mainMethodReturnType, final String... mainMethodSnippet)
	throws UnableToCompleteException {
	if (logger == null) {
	logger = this.logger;
	}
	String snippet = Joiner.on("\n").join(mainMethodSnippet);
	JProgram program = compileSnippet(logger, mainMethodReturnType, snippet, true);
	JMethod method = findMethod(program, methodName);
	boolean madeChanges = doOptimizeMethod(logger, program, method);
	if (madeChanges && runDeadCodeElimination) {
	DeadCodeElimination.exec(program);
	}
	return new Result(program, mainMethodReturnType, methodName, snippet, madeChanges);
	}

	protected abstract boolean doOptimizeMethod(TreeLogger logger, JProgram program, JMethod method)
	throws UnableToCompleteException;
	}