import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
/**
 * Returns compiler options which are safe for compilation of a cajoled
 * module. The set of options is similar to the one which is used by
 * CompilationLevel in simple mode. The main difference is that variable
 * renaming and closurePass options are turned off.
 */
private CompilerOptions getSecureCompilerOptions() {
  CompilerOptions options = new CompilerOptions();

  options.variableRenaming = VariableRenamingPolicy.OFF;
  options.setInlineVariables(Reach.LOCAL_ONLY);
  options.inlineLocalFunctions = true;
  options.checkGlobalThisLevel = CheckLevel.OFF;
  options.coalesceVariableNames = true;
  options.deadAssignmentElimination = true;
  options.collapseVariableDeclarations = true;
  options.convertToDottedProperties = true;
  options.labelRenaming = true;
  options.removeDeadCode = true;
  options.optimizeArgumentsArray = true;
  options.removeUnusedVars = false;
  options.removeUnusedLocalVars = true;

  return options;
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
InlineFunctions(
    AbstractCompiler compiler,
    Supplier<String> safeNameIdSupplier,
    Reach reach,
    boolean assumeStrictThis,
    boolean assumeMinimumCapture,
    int maxSizeAfterInlining) {
  checkArgument(compiler != null);
  checkArgument(safeNameIdSupplier != null);
  checkArgument(reach != Reach.NONE);

  this.compiler = compiler;

  this.reach = reach;
  this.assumeMinimumCapture = assumeMinimumCapture;

  this.maxSizeAfterInlining = maxSizeAfterInlining;
  this.enforceMaxSizeAfterInlining =
      maxSizeAfterInlining != CompilerOptions.UNLIMITED_FUN_SIZE_AFTER_INLINING;

  this.injector =
      new FunctionInjector(
          compiler, safeNameIdSupplier, true, assumeStrictThis, assumeMinimumCapture);
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testBug31448683() {
  CompilerOptions options = createCompilerOptions();
  WarningLevel.QUIET.setOptionsForWarningLevel(options);
  options.setInlineFunctions(Reach.ALL);
  test(
      options,
      LINE_JOINER.join(
          "function f() {",
          "  x = x || 1",
          "  var x;",
          "  console.log(x);",
          "}",
          "for (var _ in [1]) {",
          "  f();",
          "}"),
      LINE_JOINER.join(
          "for(var _ in[1]) {",
          "  {",
          "     var x$jscomp$inline_0 = void 0;",
          "     x$jscomp$inline_0 = x$jscomp$inline_0 || 1;",
          "     console.log(x$jscomp$inline_0);",
          "  }",
          "}"));
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testNameAnonymousFunctionsWithVarRemoval() {
  CompilerOptions options = createCompilerOptions();
  options.setRemoveUnusedVariables(CompilerOptions.Reach.LOCAL_ONLY);
  options.setInlineVariables(true);
  String code = "var f = function longName() {}; var g = function() {};" +
      "function longerName() {} var i = longerName;";
  test(options, code,
       "var f = function() {}; var g = function() {}; " +
       "var i = function() {};");

  options.setAnonymousFunctionNaming(AnonymousFunctionNamingPolicy.MAPPED);
  test(options, code,
      "var f = function longName() {}; var g = function $() {};"
      + "var i = function longerName(){};");
  assertNotNull(lastCompiler.getResult().namedAnonFunctionMap);

  options.setAnonymousFunctionNaming(AnonymousFunctionNamingPolicy.UNMAPPED);
  test(options, code,
      "var f = function longName() {}; var g = function $g$() {};"
      + "var i = function longerName(){};");
  assertNull(lastCompiler.getResult().namedAnonFunctionMap);
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testNoCrash_varInCatch() {
  CompilerOptions options = createCompilerOptions();
  options.setInlineFunctions(Reach.ALL);

  test(
      options,
      LINE_JOINER.join(
          "(function() {",
          "  try {",
          "    x = 2;",
          "  } catch (e) {",
          "    var x = 1;",
          "  }",
          "})();"),
    LINE_JOINER.join(
          "{ try {",
          "    x$jscomp$inline_0=2",
          "  } catch(e) {",
          "    var x$jscomp$inline_0=1",
          "  }",
          "}"));
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testJQueryStringSplitLoops() {
  CompilerOptions options = createCompilerOptions();
  options.setFoldConstants(true);
  test(options, "var x=['1','2','3','4','5','6','7']", "var x='1234567'.split('')");

  options = createCompilerOptions();
  options.setFoldConstants(true);
  options.setComputeFunctionSideEffects(false);
  options.setRemoveUnusedVariables(Reach.ALL);

  // If we do splits too early, it would add a side-effect to x.
  test(options,
    "var x=['1','2','3','4','5','6','7']",
    "");

}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testInlineObject() {
  disableCompareAsTree();
  enableMarkNoSideEffects();

  this.inliningReach = Reach.LOCAL_ONLY;
  assumeStrictThis = true;
  assumeMinimumCapture = true;

  // TODO(johnlenz): normalize the AST so an AST comparison can be done.
  // As is, the expected AST does not match the actual correct result:
  // The AST matches "g.a()" with a FREE_CALL annotation, but this as
  // expected string would fail as it won't be mark as a free call.
  // "(0,g.a)()" matches the output, but not the resulting AST.
  test("function inner(){function f(){return g.a}(f())()}",
      "function inner(){(0,g.a)()}");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testRemoveUnusedPrototypeProperties2() {
  CompilerOptions options = createCompilerOptions();
  String code = "function Foo() {} " +
      "Foo.prototype.bar = function() { return new Foo(); };" +
      "function f(x) { x.bar(); }";
  testSame(options, code);

  options.setRemoveUnusedPrototypeProperties(true);
  testSame(options, code);

  options.setRemoveUnusedVariables(Reach.ALL);
  test(options, code, "");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testDeadAssignmentsElimination() {
  CompilerOptions options = createCompilerOptions();
  String code = "function f() { var x = 3; 4; x = 5; return x; } f(); ";
  testSame(options, code);

  options.setDeadAssignmentElimination(true);
  testSame(options, code);

  options.setRemoveUnusedVariables(Reach.ALL);
  test(options, code, "function f() { 3; 4; var x = 5; return x; } f();");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testInlineFunctions() {
  CompilerOptions options = createCompilerOptions();
  String code = "function f() { return 3; } f(); ";
  testSame(options, code);

  options.setInlineFunctions(Reach.ALL);
  test(options, code, "3;");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testRemoveUnusedVars1() {
  CompilerOptions options = createCompilerOptions();
  String code = "function f(x) {} f();";
  testSame(options, code);

  options.setRemoveUnusedVariables(Reach.ALL);
  test(options, code, "function f() {} f();");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testRemoveUnusedVars2() {
  CompilerOptions options = createCompilerOptions();
  String code = "(function f(x) {})();var g = function() {}; g();";
  testSame(options, code);

  options.setRemoveUnusedVariables(Reach.ALL);
  test(options, code, "(function() {})();var g = function() {}; g();");

  options.setAnonymousFunctionNaming(AnonymousFunctionNamingPolicy.UNMAPPED);
  test(options, code, "(function f() {})();var g = function $g$() {}; g();");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testFlowSensitiveInlineVariables1() {
  CompilerOptions options = createCompilerOptions();
  String code = "function f() { var x = 3; x = 5; return x; }";
  testSame(options, code);

  options.setInlineVariables(true);
  test(options, code, "function f() { var x = 3; return 5; }");

  String unusedVar = "function f() { var x; x = 5; return x; } f()";
  test(options, unusedVar, "(function f() { var x; return 5; })()");

  options.setRemoveUnusedVariables(Reach.ALL);
  test(options, unusedVar, "(function () { return 5; })()");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testsyntheticBlockOnDeadAssignments() {
  CompilerOptions options = createCompilerOptions();
  options.setDeadAssignmentElimination(true);
  options.setRemoveUnusedVariables(Reach.ALL);
  options.syntheticBlockStartMarker = "START";
  options.syntheticBlockEndMarker = "END";
  test(options, "var x; x = 1; START(); x = 1;END();x()",
                "var x; x = 1;{START();{x = 1}END()}x()");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testMaxFunSizeAfterInliningUsage() {
  CompilerOptions options = new CompilerOptions();
  options.setInlineFunctions(Reach.NONE);
  options.setMaxFunctionSizeAfterInlining(1);
  try {
    test(options, "", "");
    fail("Expected CompilerOptionsPreprocessor.InvalidOptionsException");
  } catch (RuntimeException e) {
    if (!(e instanceof CompilerOptionsPreprocessor.InvalidOptionsException)) {
      fail("Expected CompilerOptionsPreprocessor.InvalidOptionsException");
    }
  }
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  maybeEnableInferConsts();
  enableNormalize();
  enableComputeSideEffects();
  inliningReach = Reach.ALL;
  assumeStrictThis = false;
  assumeMinimumCapture = false;
  maxSizeAfterInlining = CompilerOptions.UNLIMITED_FUN_SIZE_AFTER_INLINING;
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testLocalFunctionInliningOnly2() {
  this.inliningReach = Reach.LOCAL_ONLY;
  testSame("function f(){} f()");

  test("function f(){ function g() {return 1} return g() }; f();",
       "function f(){ return 1 }; f();");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testLocalFunctionInliningOnly3() {
  this.inliningReach = Reach.LOCAL_ONLY;
  testSame("function f(){} f()");

  test("(function(){ function g() {return 1} return g() })();",
       "(function(){ return 1 })();");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void testLocalFunctionInliningOnly4() {
  this.inliningReach = Reach.LOCAL_ONLY;
  testSame("function f(){} f()");

  test("(function(){ return (function() {return 1})() })();",
       "(function(){ return 1 })();");
}
 

import com.google.javascript.jscomp.CompilerOptions.Reach; //导入依赖的package包/类
public void setInlineFunctions(Reach reach) {
    compilerOptions.setInlineFunctions(reach);
}