dev/core/test/com/google/gwt/dev/jjs/impl/codesplitter/CodeSplitterTest.java

/*
 * Copyright 2011 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.codesplitter;

import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.dev.CompilerContext;
import com.google.gwt.dev.PrecompileTaskOptions;
import com.google.gwt.dev.PrecompileTaskOptionsImpl;
import com.google.gwt.dev.cfg.BindingProperty;
import com.google.gwt.dev.cfg.ConditionNone;
import com.google.gwt.dev.cfg.ConfigurationProperty;
import com.google.gwt.dev.jjs.JsOutputOption;
import com.google.gwt.dev.jjs.ast.JClassType;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JPrimitiveType;
import com.google.gwt.dev.jjs.ast.JType;
import com.google.gwt.dev.jjs.impl.FullCompileTestBase;
import com.google.gwt.dev.jjs.impl.JavaToJavaScriptMap;
import com.google.gwt.dev.js.ast.JsBlock;
import com.google.gwt.dev.js.ast.JsContext;
import com.google.gwt.dev.js.ast.JsExprStmt;
import com.google.gwt.dev.js.ast.JsFunction;
import com.google.gwt.dev.js.ast.JsName;
import com.google.gwt.dev.js.ast.JsNode;
import com.google.gwt.dev.js.ast.JsVisitor;
import com.google.gwt.dev.util.Pair;
import com.google.gwt.thirdparty.guava.common.collect.Sets;

import java.util.List;
import java.util.Set;

/**
 * Unit test for {@link com.google.gwt.dev.jjs.impl.codesplitter.CodeSplitter}.
 */
public class CodeSplitterTest extends FullCompileTestBase {

  /**
   * A {@link MultipleDependencyGraphRecorder} that does nothing.
   */
  private static final MultipleDependencyGraphRecorder NULL_RECORDER =
      new MultipleDependencyGraphRecorder() {
        @Override
        public void close() {
        }

        @Override
        public void endDependencyGraph() {
        }

        @Override
        public void methodIsLiveBecause(JMethod liveMethod, List<JMethod> dependencyChain) {
        }

        @Override
        public void open() {
        }

        @Override
        public void startDependencyGraph(String name, String extnds) {
        }
      };

  // These will be the functions that are shared between fragments. This unit test will
  // be based for finding these function in the proper fragments.
  private final String functionA = "public static void functionA() {}";
  private final String functionB = "public static void functionB() {}";
  private final String functionC = "public static void functionC() {}";
  private final String functionD = "public static void functionD() {}";
  private final String initialA = "public static void initialA() {}";
  private final String initialB = "public static void initialB() {}";

  private final String functionAllocateFooInt = "public static void functionAllocateFooInt() { "
      + "new Foo(42); }";

  private final String functionAllocateFooString =
      "public static void functionAllocateFooString() { new Foo(\"Hello\"); }";

  public int leftOverMergeSize = 0;
  public int expectedFragmentCount = 0;

  private ConfigurationProperty initialSequenceProp =
      new ConfigurationProperty(CodeSplitters.PROP_INITIAL_SEQUENCE, true);

  private boolean closureOutputFormat = false;
  private JavaToJavaScriptMap currentJjsMap;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    // Compilation Configuration Properties.
    BindingProperty stackMode = new BindingProperty("compiler.stackMode");
    stackMode.addDefinedValue(new ConditionNone(), "STRIP");
    setProperties(new BindingProperty[]{stackMode}, new String[]{"STRIP"},
        new ConfigurationProperty[]{initialSequenceProp});
    currentJjsMap = null;
  }

  public void testSimple() throws UnableToCompleteException {
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append("static {");
    // code.append("  functionC();");
    code.append("}");
    code.append(functionA);
    code.append(functionB);
    code.append(functionC);
    code.append("  public static void onModuleLoad() {\n");
    code.append("functionC();");
    // Fragment #1
    code.append(createRunAsync("functionA();"));
    // Fragment #1 (merged)
    code.append(createRunAsync("functionA(); functionB();"));
    // Fragment #2
    code.append(createRunAsync("functionC();"));
    code.append("  }\n");
    code.append("}\n");

    expectedFragmentCount = 4;
    compileSnippetToJS(code.toString());

    // init + 2 fragments + leftover.
    assertFragmentCount(4);
    assertInFragment("functionA", 1);

    // Verify that functionA isn't duplicated else where.
    assertNotInFragment("functionA", 0);
    assertNotInFragment("functionA", 2);
    assertNotInFragment("functionA", 3);

    assertInFragment("functionB", 1);

    // functionC must be in the initial fragment.
    assertInFragment("functionC", 0);
  }

  public void testClosureConstructorPrototypeMovement() throws UnableToCompleteException {
    closureOutputFormat = true;
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append("static class Foo {");
    code.append("  int x; String y;\n");
    code.append("  public Foo(int x) { this.x = x; }\n");
    code.append("  public Foo(String y) { this.y = y; }\n");
    code.append("};");
    code.append(functionAllocateFooInt);
    code.append(functionAllocateFooString);
    code.append("  public static void onModuleLoad() {\n");
    code.append("functionAllocateFooInt();");
//  Fragment #1
    code.append(createRunAsync("functionAllocateFooString();"));
    code.append("  }\n");
    code.append("}\n");

    expectedFragmentCount = 3;
    compileSnippetToJS(code.toString());

    // init + 1 fragments + leftover.
    assertFragmentCount(3);

    // ------- Verify Fragment 0 -------
    // Int related function and int ctor, plus prototype ctor in fragment 0
    assertInFragment("functionAllocateFooInt", 0);

    // assert synthetic prototype ctor is in fragment 0
    assertClosureTypeCtorInFragment("EntryPoint$Foo", 0);

    // and int ctor in fragment 0
    assertClosureMethodInFragment("EntryPoint$Foo", 0, JPrimitiveType.INT);

    // we also don't want string related ctor stuff in fragment 0
    assertNotInFragment("functionAllocateFooString", 0);
    JClassType stringType = jProgram.getTypeJavaLangString();
    assertClosureFunctionNotInFragment("EntryPoint$Foo", 0, stringType);

    assertPrototypeAssignmentStatementInFragment("EntryPoint$Foo", 0, JPrimitiveType.INT);
    assertPrototypeAssignmentStatementNotInFragment("EntryPoint$Foo", 0, stringType);

    // ------- Verify fragment 1 -------
    // check if string ctor and related code is in fragment 1
    assertInFragment("functionAllocateFooString", 1);
    assertClosureMethodInFragment("EntryPoint$Foo", 1, stringType);
    assertPrototypeAssignmentStatementInFragment("EntryPoint$Foo", 1, stringType);
    assertPrototypeAssignmentStatementNotInFragment("EntryPoint$Foo", 1, JPrimitiveType.INT);

    // Verify that the Class prototype ctor isn't duplicated here
    assertClosureTypeCtorNotInFragment("EntryPoint$Foo", 1);

    // but no int related code is here
    assertNotInFragment("functionAllocateFooInt", 1);
    assertClosureFunctionNotInFragment("EntryPoint$Foo", 1, JPrimitiveType.INT);

    // Verify fragment 2 (leftovers)
    assertNotInFragment("functionAllocateFooInt", 2);
    assertNotInFragment("functionAllocateFooString", 2);

    assertClosureFunctionNotInFragment("EntryPoint$Foo", 2, JPrimitiveType.INT);
    assertClosureFunctionNotInFragment("EntryPoint$Foo", 2, stringType);
    assertClosureTypeCtorNotInFragment("EntryPoint$Foo", 2);
    assertPrototypeAssignmentStatementNotInFragment("EntryPoint$Foo", 2, JPrimitiveType.INT);
    assertPrototypeAssignmentStatementNotInFragment("EntryPoint$Foo", 2, stringType);
  }

  public void testPredefinedAsyncGrouping() throws UnableToCompleteException {
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append(functionA);
    code.append(functionB);
    code.append(functionC);
    code.append(functionD);
    code.append(createNamedRunAsyncCallback("RunAsyncCallBack1", "functionA(); functionD();"));
    code.append(createNamedRunAsyncCallback("RunAsyncCallBack2", "functionB(); functionD();"));
    code.append(createNamedRunAsyncCallback("RunAsyncCallBack3", "functionC();"));

    code.append("  public static void onModuleLoad() {\n");
    // Fragment #1
    code.append("createCallBack1();");
    // Fragment #2
    code.append("createCallBack2();");
    code.append("createCallBack3();");

    code.append("  }\n");
    code.append("  private static void createCallBack1() {\n");
    code.append("    GWT.runAsync( new RunAsyncCallBack1() );");
    code.append("  }\n");
    code.append("  private static void createCallBack2() {\n");
    code.append("    GWT.runAsync(RunAsyncCallBack2.class, new RunAsyncCallBack2() );");
    code.append("  }\n");
    code.append("  private static void createCallBack3() {\n");
    code.append("    GWT.runAsync(RunAsyncCallBack2.class, new RunAsyncCallBack3() );");
    code.append("  }\n");
    code.append("}\n");

    // Use 1 to 1 merging.
    expectedFragmentCount = -1;
    compileSnippetToJS(code.toString());

    // 1 initial + 2 fragments + leftover.
    assertFragmentCount(4);
    // TODO(rluble): using fragment numbers here is kind of tricky as the ordering is not
    // guaranteed.

    // functionB must be in the fragment #2. As first are all the user specified merges.
    assertInFragment("functionA", 2);

    // Verify that functionA isn't duplicated else where.
    assertNotInFragment("functionA", 0);
    assertNotInFragment("functionA", 1);
    assertNotInFragment("functionA", 3);

    // functionB must be in the fragment #1.
    assertInFragment("functionB", 1);

    // functionC must be in the fragment #1.
    assertInFragment("functionC", 1);

    // functionC must be in the leftover.
    assertInFragment("functionD", 3);
  }


  public void testSimpleWithInitialSequence() throws UnableToCompleteException {
    // Set up configuration property.
    initialSequenceProp.addValue("@test.EntryPoint::createInitialCallBack1()");
    initialSequenceProp.addValue("@test.EntryPoint::createInitialCallBack2()");

    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append(functionA);
    code.append(functionB);
    code.append(functionC);
    code.append(initialA);
    code.append(initialB);
    code.append(createNamedRunAsyncCallback("InitialRunAsyncCallBack1", "initialA();"));
    code.append(createNamedRunAsyncCallback("InitialRunAsyncCallBack2", "initialB();"));

    code.append("  public static void onModuleLoad() {\n");
    code.append("functionC();");
    // Fragment #3
    code.append(createRunAsync("functionA();"));
    // Fragment #3 (merged)
    code.append(createRunAsync("functionA(); functionB();"));
    // Fragment #4
    code.append(createRunAsync("functionC();"));
    // initial fragments #1, #2
    code.append("createInitialCallBack1();");
    code.append("createInitialCallBack2();");
    code.append("  }\n");
    code.append("  private static void createInitialCallBack1() {\n");
    code.append("    GWT.runAsync( new InitialRunAsyncCallBack1() );");
    code.append("  }\n");
    code.append("  private static void createInitialCallBack2() {\n");
    code.append("    GWT.runAsync( new InitialRunAsyncCallBack2() );");
    code.append("  }\n");
    code.append("}\n");

    expectedFragmentCount = 6;
    compileSnippetToJS(code.toString());

    // 3 initial + 2 fragments + leftover.
    assertFragmentCount(6);
    assertInFragment("functionA", 3);

    // Verify that functionA isn't duplicated else where.
    assertNotInFragment("functionA", 0);
    assertNotInFragment("functionA", 1);
    assertNotInFragment("functionA", 2);
    assertNotInFragment("functionA", 4);
    assertNotInFragment("functionA", 5);

    assertInFragment("functionB", 3);

    // functionC must be in the initial fragment.
    assertInFragment("functionC", 0);

    // initialA must be in the initial fragment #1.
    assertInFragment("initialA", 1);

    // functionC must be in the initial fragment #2.
    assertInFragment("initialB", 2);
  }

  public void testOnSuccessCallCast() throws UnableToCompleteException {
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append("  " + functionA);
    code.append("  " + functionB);
    code.append("  " + functionC);
    code.append("  public static void onModuleLoad() {\n");
    code.append("    functionC();");
    code.append("    " + createRunAsync("(RunAsyncCallback)", "functionA();"));
    code.append("    " + createRunAsync("(RunAsyncCallback)", "functionB();"));
    code.append("  }\n");
    code.append("}\n");

    expectedFragmentCount = 4;
    compileSnippetToJS(code.toString());

    // init + 2 fragments + leftover.
    assertFragmentCount(4);

    assertInFragment("functionA", 1);
    assertInFragment("functionB", 2);

    // Verify that functionA and B aren't in the leftover.
    assertNotInFragment("functionA", 3);
    assertNotInFragment("functionB", 3);
  }

  public void testMergeLeftOvers() throws UnableToCompleteException {
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append(functionA);
    code.append(functionB);
    code.append(functionC);
    code.append("  public static void onModuleLoad() {\n");
    // Fragment #1
    code.append(createRunAsync("functionA();"));
    // Fragment #2
    code.append(createRunAsync("functionB();"));
    // Fragment #3
    code.append(createRunAsync("functionC();"));
    code.append("  }\n");
    code.append("}\n");

    expectedFragmentCount = 2;
    leftOverMergeSize = 100 * 1024 /* 100k minumum */;
    this.compileSnippetToJS(code.toString());

    // init + leftover.
    assertFragmentCount(2);
    assertInFragment("functionA", 1);
    assertInFragment("functionB", 1);
    assertInFragment("functionC", 1);
  }

  /**
   * Test that the conversion from -XfragmentCount expectCount into number of exclusive fragments
   * is correct.
   */
  public void testExpectedFragmentCountFromFragmentMerge() {

    // Exclusive fragments are totalFragments - (1 + initials) - leftovers.
    assertEquals(40, CodeSplitters.getNumberOfExclusiveFragmentFromExpectedFragmentCount(2, 44));

    // This is a non negative number always
    assertEquals(0, CodeSplitters.getNumberOfExclusiveFragmentFromExpectedFragmentCount(2, 1));
  }

  public void testDontMergeLeftOvers() throws UnableToCompleteException {
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append(functionA);
    code.append(functionB);
    code.append(functionC);
    code.append("  public static void onModuleLoad() {\n");
    // Fragment #1
    code.append(createRunAsync("functionA();"));
    // Fragment #2
    code.append(createRunAsync("functionB();"));
    // Fragment #3
    code.append(createRunAsync("functionC();"));
    code.append("  }\n");
    code.append("}\n");

    // we want don't want them to be merged
    leftOverMergeSize = 10;
    expectedFragmentCount = 5;
    this.compileSnippetToJS(code.toString());

    // init + 3 exlclusive fragments + leftover.
    assertFragmentCount(5);
    assertNotInFragment("functionA", 4);
    assertNotInFragment("functionB", 4);
    assertNotInFragment("functionC", 4);
  }

  public void testNoMergeMoreThanTwo() throws UnableToCompleteException {
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append(functionA);
    code.append(functionB);
    code.append(functionC);
    code.append("  public static void onModuleLoad() {\n");
    // Fragment #1
    code.append(createRunAsync("functionA();"));
    // Fragment #2
    code.append(createRunAsync("functionA();"));
    // Fragment #3
    code.append(createRunAsync("functionA();"));
    code.append("  }\n");
    code.append("}\n");

    expectedFragmentCount = 2;
    compileSnippetToJS(code.toString());

    // There is no common code shared between any pair.

    // init + 3 fragments + leftover.
    assertFragmentCount(5);
  }

  public void testDoubleMerge() throws UnableToCompleteException {
    StringBuilder code = new StringBuilder();
    code.append("package test;\n");
    code.append("import com.google.gwt.core.client.GWT;\n");
    code.append("import com.google.gwt.core.client.RunAsyncCallback;\n");
    code.append("public class EntryPoint {\n");
    code.append(functionA);
    code.append(functionB);
    code.append(functionC);
    code.append("  public static void onModuleLoad() {\n");
    // Fragment #1
    code.append(createRunAsync("functionA();"));
    // Fragment #1
    code.append(createRunAsync("functionA(); functionC();"));
    // Fragment #2
    code.append(createRunAsync("functionB(); functionC();"));
    // Fragment #2
    code.append(createRunAsync("functionB(); functionC();"));
    code.append("  }\n");
    code.append("}\n");

    expectedFragmentCount = 4;
    compileSnippetToJS(code.toString());

    // init + 2 fragments + leftover.
    assertFragmentCount(4);
    assertInFragment("functionA", 1);
    assertInFragment("functionB", 2);
    assertInFragment("functionC", 3);
  }

  private void assertFragmentCount(int num) {
    assertEquals(num, jsProgram.getFragmentCount());
  }

  private void assertInFragment(String functionName, int expectedFragmentNumber) {
    Set<Integer> fragments = Sets.newHashSet();
    for (int fragmentNumber = 0; fragmentNumber < jsProgram.getFragmentCount(); fragmentNumber++) {
      JsBlock fragment = jsProgram.getFragmentBlock(fragmentNumber);
      if (findFunctionIn(functionName, fragment)) {
        fragments.add(fragmentNumber);
      }
    }
    assertTrue("function " + functionName + " should be in fragments " + expectedFragmentNumber +
        " but is in " + fragments, fragments.equals(Sets.newHashSet(expectedFragmentNumber)));
  }

  private void assertClosureTypeCtorInFragment(String functionName, int expectedFragmentNumber) {
    Set<Integer> fragments = Sets.newHashSet();
    for (int fragmentNumber = 0; fragmentNumber < jsProgram.getFragmentCount(); fragmentNumber++) {
      JsBlock fragment = jsProgram.getFragmentBlock(fragmentNumber);
      if (findClosureTypeFunctionIn(functionName, fragment)) {
        fragments.add(fragmentNumber);
      }
    }
    assertTrue("function " + functionName + " should be in fragments " + expectedFragmentNumber +
        " but is in " + fragments, fragments.equals(Sets.newHashSet(expectedFragmentNumber)));
  }

  private void assertClosureMethodInFragment(String functionName, int expectedFragmentNumber,
      JType... args) {
    Set<Integer> fragments = Sets.newHashSet();
    for (int fragmentNumber = 0; fragmentNumber < jsProgram.getFragmentCount(); fragmentNumber++) {
      JsBlock fragment = jsProgram.getFragmentBlock(fragmentNumber);
      if (findClosureFunctionIn(functionName, fragment, args)) {
        fragments.add(fragmentNumber);
      }
    }
    assertTrue("function " + functionName + " should be in fragments " + expectedFragmentNumber +
        " but is in " + fragments, fragments.equals(Sets.newHashSet(expectedFragmentNumber)));
  }

  private void assertPrototypeAssignmentStatementInFragment(String functionName,
      int expectedFragmentNumber, JType... args) {
    Set<Integer> fragments = Sets.newHashSet();
    for (int fragmentNumber = 0; fragmentNumber < jsProgram.getFragmentCount(); fragmentNumber++) {
      JsBlock fragment = jsProgram.getFragmentBlock(fragmentNumber);
      if (findPrototypeChainStatementIn(functionName, fragment, args)) {
        fragments.add(fragmentNumber);
      }
    }
    assertTrue("Prototype chain assignment for " + functionName + " should be in "
        + "fragments " + expectedFragmentNumber + " but is in " + fragments,
        fragments.equals(Sets.newHashSet(expectedFragmentNumber)));
  }

  private void assertNotInFragment(String functionName, int fragmentNum) {
    JsBlock fragment = jsProgram.getFragmentBlock(fragmentNum);
    assertFalse("function " + functionName + " should not be in fragment " + fragmentNum,
        findFunctionIn(functionName, fragment));
  }

  private void assertClosureTypeCtorNotInFragment(String functionName, int fragmentNum) {
    JsBlock fragment = jsProgram.getFragmentBlock(fragmentNum);
    assertFalse("function " + functionName + " should not be in fragment " + fragmentNum,
        findClosureTypeFunctionIn(functionName, fragment));
  }

  private void assertClosureFunctionNotInFragment(String functionName, int fragmentNum, JType...
      args) {
    JsBlock fragment = jsProgram.getFragmentBlock(fragmentNum);
    assertFalse("function " + functionName + " should not be in fragment " + fragmentNum,
        findClosureFunctionIn(functionName, fragment, args));
  }

  private void assertPrototypeAssignmentStatementNotInFragment(String functionName, int
      fragmentNum, JType... args) {
    JsBlock fragment = jsProgram.getFragmentBlock(fragmentNum);
    assertFalse("function " + functionName + " should not be in fragment " + fragmentNum,
        findPrototypeChainStatementIn(functionName, fragment, args));
  }

  /**
   * @return true if the function exists in that fragment.
   */
  private static boolean findFunctionIn(final String functionName, JsBlock fragment) {
    final boolean[] found = {false};
    JsVisitor visitor = new JsVisitor() {
      @Override
      public boolean visit(JsFunction x, JsContext ctx) {
        JsName jsName = x.getName();
        if (jsName != null && jsName.getShortIdent().equals(functionName)) {
          found[0] = true;
        }
        return false;
      }
    };
    visitor.accept(fragment);
    return found[0];
  }

  /**
   * @return true if the function exists in that fragment and it mapes to a classType
   */
  private boolean findClosureTypeFunctionIn(final String functionName, JsBlock fragment) {
    final boolean[] found = {false};
    JsVisitor visitor = new JsVisitor() {
      @Override
      public boolean visit(JsFunction x, JsContext ctx) {
        JsName jsName = x.getName();
        if (jsName != null && jsName.getShortIdent().equals(functionName)
            && currentJjsMap.nameToType(jsName) != null) {
          found[0] = true;
        }
        return false;
      }
    };
    visitor.accept(fragment);
    return found[0];
  }

  /**
   * @return true if the function exists in that fragment and it maps to a function
   * with the expected args.
   */
  private boolean findClosureFunctionIn(final String functionName, JsBlock fragment,
      final JType... args) {
    final boolean[] found = {false};
    JsVisitor visitor = new JsVisitor() {
      @Override
      public boolean visit(JsFunction x, JsContext ctx) {
        JsName jsName = x.getName();
        if (jsName != null && jsName.getShortIdent().equals(functionName)) {
          JMethod meth = currentJjsMap.nameToMethod(jsName);
          if (meth != null) {
            found[0] = checkArguments(meth, args);
          }
        }
        return false;
      }
    };
    visitor.accept(fragment);
    return found[0];
  }

  /**
   * @return true if a statement of the form FunctionName.prototype = ClassFunction.prototype
   */
  private boolean findPrototypeChainStatementIn(final String functionName, JsBlock fragment,
      final JType... args) {
    class PrototypeChainFinderVisitor extends JsVisitor {
      boolean found = false;
      @Override
      public boolean visit(JsExprStmt x, JsContext ctx) {
        JMethod method = currentJjsMap.methodForStatement(x);
        JsName jsName = currentJjsMap.nameForMethod(method);
        if (method != null && jsName != null && jsName.getShortIdent().equals(functionName)) {
          found = checkArguments(method, args);
        }
        return false;
      }
    };
    PrototypeChainFinderVisitor visitor = new PrototypeChainFinderVisitor();
    visitor.accept(fragment);
    return visitor.found;
  }

  private boolean checkArguments(JMethod method, JType[] args) {
    for (int i = 0; i < args.length; i++) {
      if (method.getParams().get(i).getType().getUnderlyingType() != args[i]) {
        return false;
      }
    }
    return true;
  }

  @Override
  protected void optimizeJava() {
  }

  @Override
  protected CompilerContext provideCompilerContext() {
    PrecompileTaskOptions options = new PrecompileTaskOptionsImpl();
    options.setOutput(JsOutputOption.PRETTY);
    options.setRunAsyncEnabled(true);
    if (closureOutputFormat) {
      options.setClosureCompilerFormatEnabled(true);
    }
    return new CompilerContext.Builder().options(options).build();
  }

  @Override
  protected Pair<JavaToJavaScriptMap, Set<JsNode>> compileSnippetToJS(final String code)
      throws UnableToCompleteException {
    currentJjsMap = super.compileSnippetToJS(code).getLeft();
    CodeSplitter.exec(logger, jProgram, jsProgram, currentJjsMap, expectedFragmentCount,
        leftOverMergeSize,
       NULL_RECORDER);
    return null;
  }

  private static String createRunAsync(String cast, String body) {
    StringBuilder code = new StringBuilder();
    code.append("GWT.runAsync(" + cast + "new " + "RunAsyncCallback() {\n");
    code.append("  public void onFailure(Throwable reason) {}\n");
    code.append("  public void onSuccess() {\n");
    code.append("    " + body);
    code.append("  }\n");
    code.append("});\n");
    return code.toString();
  }

  private static String createNamedRunAsyncCallback(String className, String body) {
    StringBuilder code = new StringBuilder();
    code.append("private static class " + className + " implements RunAsyncCallback {\n");
    code.append("  public void onFailure(Throwable reason) {}\n");
    code.append("  public void onSuccess() {\n");
    code.append("    " + body);
    code.append("  }\n");
    code.append("}\n");
    return code.toString();
  }

  private static String createRunAsync(String body) {
    return createRunAsync("", body);
  }
}