Java InliningMode类代码示例

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
void maybeAddReference(NodeTraversal t, FunctionState fs,
    Node callNode, JSModule module) {
  if (!fs.canInline()) {
    return;
  }

  boolean referenceAdded = false;
  InliningMode mode = fs.canInlineDirectly()
       ? InliningMode.DIRECT : InliningMode.BLOCK;
  referenceAdded = maybeAddReferenceUsingMode(
      t, fs, callNode, module, mode);
  if (!referenceAdded &&
      mode == InliningMode.DIRECT && blockFunctionInliningEnabled) {
    // This reference can not be directly inlined, see if
    // block replacement inlining is possible.
    mode = InliningMode.BLOCK;
    referenceAdded = maybeAddReferenceUsingMode(
        t, fs, callNode, module, mode);
  }

  if (!referenceAdded) {
    // Don't try to remove a function if we can't inline all
    // the references.
    fs.setRemove(false);
  }
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
private boolean maybeAddReferenceUsingMode(
    NodeTraversal t, FunctionState fs, Node callNode,
    JSModule module, InliningMode mode) {
  CanInlineResult result = injector.canInlineReferenceToFunction(
      t, callNode, fs.getFn().getFunctionNode(),
      fs.getNamesToAlias(), mode, fs.getReferencesThis());
  if (result != CanInlineResult.NO) {
    // Yeah!
    boolean decompose =
      (result == CanInlineResult.AFTER_DECOMPOSITION);
    fs.addReference(new Reference(callNode, module, mode, decompose));
    return true;
  }

  return false;
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
void maybeAddReference(NodeTraversal t, FunctionState functionState,
    Node callNode, JSModule module) {
  if (!functionState.canInline()) {
    return;
  }

  InliningMode mode = functionState.canInlineDirectly()
      ? InliningMode.DIRECT : InliningMode.BLOCK;
  boolean referenceAdded = maybeAddReferenceUsingMode(t, functionState, callNode, module, mode);
  if (!referenceAdded && mode == InliningMode.DIRECT) {
    // This reference can not be directly inlined, see if
    // block replacement inlining is possible.
    mode = InliningMode.BLOCK;
    referenceAdded = maybeAddReferenceUsingMode(t, functionState, callNode, module, mode);
  }

  if (!referenceAdded) {
    // Don't try to remove a function if we can't inline all
    // the references.
    functionState.setRemove(false);
  }
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
/**
 * Inline a function into the call site.
 */
private void inlineFunction(
    NodeTraversal t, Node callNode, FunctionState fs, InliningMode mode) {
  Function fn = fs.getFn();
  String fnName = fn.getName();
  Node fnNode = fs.getSafeFnNode();

  Node newCode = injector.inline(t, callNode, fnName, fnNode, mode);
  t.getCompiler().reportCodeChange();
  t.getCompiler().addToDebugLog("Inlined function: " + fn.getName());
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
void removeBlockInliningReferences() {
  Iterator<Entry<Node, Reference>> i;
  for (i = getReferencesInternal().entrySet().iterator(); i.hasNext();) {
    Entry<Node, Reference> entry = i.next();
    if (entry.getValue().mode == InliningMode.BLOCK) {
      i.remove();
    }
  }
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
public boolean hasBlockInliningReferences() {
  for (Reference r : getReferencesInternal().values()) {
    if (r.mode == InliningMode.BLOCK) {
      return true;
    }
  }
  return false;
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
public void helperCanInlineReferenceToFunction(
    final CanInlineResult expectedResult,
    final String code,
    final String fnName,
    final InliningMode mode,
    boolean allowDecomposition
    ) {
  final Compiler compiler = new Compiler();
  final FunctionInjector injector = new FunctionInjector(
      compiler, compiler.getUniqueNameIdSupplier(), allowDecomposition);
  final Node tree = parse(compiler, code);

  Node externsRoot = new Node(Token.EMPTY);
  Node mainRoot = tree;

  final Node fnNode = findFunction(tree, fnName);
  final Set<String> unsafe =
      FunctionArgumentInjector.findModifiedParameters(fnNode);

  // can-inline tester
  Method tester = new Method() {
    public boolean call(NodeTraversal t, Node n, Node parent) {
      CanInlineResult result = injector.canInlineReferenceToFunction(
          t, n, fnNode, unsafe, mode, NodeUtil.referencesThis(fnNode));
      assertEquals(expectedResult, result);
      return true;
    }
  };

  compiler.resetUniqueNameId();
  TestCallback test = new TestCallback(fnName, tester);
  NodeTraversal.traverse(compiler, tree, test);
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
private boolean maybeAddReferenceUsingMode(
    NodeTraversal t, FunctionState fs, Node callNode,
    JSModule module, InliningMode mode) {

  if (specializationState != null) {
    // If we're specializing, make sure we can fixup
    // the containing function before inlining
    Node containingFunction = getContainingFunction(t);
    if (containingFunction != null && !specializationState.canFixupFunction(
        containingFunction)) {
        return false;
    }
  }

  CanInlineResult result = injector.canInlineReferenceToFunction(
      t, callNode, fs.getFn().getFunctionNode(),
      fs.getNamesToAlias(), mode, fs.getReferencesThis(),
      fs.hasInnerFunctions());
  if (result != CanInlineResult.NO) {
    // Yeah!
    boolean decompose =
      (result == CanInlineResult.AFTER_DECOMPOSITION);
    fs.addReference(new Reference(callNode, module, mode, decompose));
    return true;
  }

  return false;
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
public void helperCanInlineReferenceToFunction(
    final CanInlineResult expectedResult,
    final String code,
    final String fnName,
    final InliningMode mode,
    boolean allowDecomposition
    ) {
  final Compiler compiler = new Compiler();
  final FunctionInjector injector = new FunctionInjector(
      compiler, compiler.getUniqueNameIdSupplier(), allowDecomposition);
  final Node tree = parse(compiler, code);

  Node externsRoot = new Node(Token.EMPTY);
  Node mainRoot = tree;

  final Node fnNode = findFunction(tree, fnName);
  final Set<String> unsafe =
      FunctionArgumentInjector.findModifiedParameters(fnNode);

  // can-inline tester
  Method tester = new Method() {
    public boolean call(NodeTraversal t, Node n, Node parent) {
      CanInlineResult result = injector.canInlineReferenceToFunction(
          t, n, fnNode, unsafe, mode,
          NodeUtil.referencesThis(fnNode),
          NodeUtil.containsFunction(NodeUtil.getFunctionBody(fnNode)));
      assertEquals(expectedResult, result);
      return true;
    }
  };

  compiler.resetUniqueNameId();
  TestCallback test = new TestCallback(fnName, tester);
  NodeTraversal.traverse(compiler, tree, test);
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
private boolean maybeAddReferenceUsingMode(
    NodeTraversal t, FunctionState fs, Node callNode,
    JSModule module, InliningMode mode) {

  if (specializationState != null) {
    // If we're specializing, make sure we can fixup
    // the containing function before inlining
    Node containingFunction = getContainingFunction(t);
    if (containingFunction != null && !specializationState.canFixupFunction(
        containingFunction)) {
        return false;
    }
  }

  CanInlineResult result = injector.canInlineReferenceToFunction(
      t, callNode, fs.getFn().getFunctionNode(),
      fs.getNamesToAlias(), mode, fs.getReferencesThis(),
      fs.hasInnerFunctions());
  if (result != CanInlineResult.NO) {
    // Yeah!
    boolean decompose =
      (result == CanInlineResult.AFTER_PREPARATION);
    fs.addReference(new Reference(callNode, module, mode, decompose));
    return true;
  }

  return false;
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
public void helperCanInlineReferenceToFunction(
    final CanInlineResult expectedResult,
    final String code,
    final String fnName,
    final InliningMode mode,
    boolean allowDecomposition) {
  final Compiler compiler = new Compiler();
  final FunctionInjector injector = new FunctionInjector(
      compiler, compiler.getUniqueNameIdSupplier(), allowDecomposition,
      assumeStrictThis,
      assumeMinimumCapture);
  final Node tree = parse(compiler, code);

  Node externsRoot = new Node(Token.EMPTY);
  Node mainRoot = tree;

  final Node fnNode = findFunction(tree, fnName);
  final Set<String> unsafe =
      FunctionArgumentInjector.findModifiedParameters(fnNode);

  // can-inline tester
  Method tester = new Method() {
    @Override
    public boolean call(NodeTraversal t, Node n, Node parent) {
      CanInlineResult result = injector.canInlineReferenceToFunction(
          t, n, fnNode, unsafe, mode,
          NodeUtil.referencesThis(fnNode),
          NodeUtil.containsFunction(NodeUtil.getFunctionBody(fnNode)));
      assertEquals(expectedResult, result);
      return true;
    }
  };

  compiler.resetUniqueNameId();
  TestCallback test = new TestCallback(fnName, tester);
  NodeTraversal.traverse(compiler, tree, test);
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
private boolean maybeAddReferenceUsingMode(
    NodeTraversal t, FunctionState functionState, Node callNode,
    JSModule module, InliningMode mode) {

  // If many functions are inlined into the same function F in the same
  // inlining round, then the size of F may exceed the max size.
  // This could be avoided if we bail later, during the inlining phase, eg,
  // in Inline#visitCallSite. However, that is not safe, because at that
  // point expression decomposition has already run, and we want to
  // decompose expressions only for the calls that are actually inlined.
  if (enforceMaxSizeAfterInlining && targetSizeAfterInlineExceedsLimit(t, functionState)) {
    return false;
  }

  Reference candidate = new Reference(callNode, t.getScope(), module, mode);
  CanInlineResult result =
      injector.canInlineReferenceToFunction(
          candidate,
          functionState.getFn().getFunctionNode(),
          functionState.getNamesToAlias(),
          functionState.getReferencesThis(),
          functionState.hasInnerFunctions());
  if (result != CanInlineResult.NO) {
    // Yeah!
    candidate.setRequiresDecomposition(result == CanInlineResult.AFTER_PREPARATION);
    functionState.addReference(candidate);
    return true;
  }

  return false;
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
void removeBlockInliningReferences() {
  Iterator<Entry<Node, Reference>> i;
  for (i = getReferencesInternal().entrySet().iterator(); i.hasNext(); ) {
    Entry<Node, Reference> entry = i.next();
    if (entry.getValue().mode == InliningMode.BLOCK) {
      i.remove();
    }
  }
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
private ClassStaticFunctionsInliner(
    Node root, String classFileName, Set<String> fnNamesToInline, InliningMode inliningMode) {
  this.root = root;
  this.classFileName = classFileName;
  this.fnNamesToInline = fnNamesToInline;
  this.inliningMode = inliningMode;

  this.injector = new FunctionInjector(compiler, safeNameIdSupplier, true, true, true);
  this.injector.setKnownConstants(fnNamesToInline);
}
 

import com.google.javascript.jscomp.FunctionInjector.InliningMode; //导入依赖的package包/类
/**
 * Test case
 *
 * var a = {}, b = {}
 * a.test = "a", b.test = "b"
 * c = a;
 * foo() { c=b; return "a" }
 * c.teste
 *
 */

public void helperCanInlineReferenceToFunction(
    final CanInlineResult expectedResult,
    final String code,
    final String fnName,
    final InliningMode mode) {
  final Compiler compiler = new Compiler();
  final FunctionInjector injector = new FunctionInjector(
      compiler, compiler.getUniqueNameIdSupplier(), allowDecomposition,
      assumeStrictThis,
      assumeMinimumCapture);
  final Node tree = parse(compiler, code);

  final Node fnNode = findFunction(tree, fnName);
  final ImmutableSet<String> unsafe =
      ImmutableSet.copyOf(FunctionArgumentInjector.findModifiedParameters(fnNode));

  // can-inline tester
  Method tester = new Method() {
    @Override
    public boolean call(NodeTraversal t, Node n, Node parent) {
      Reference ref = new Reference(n, t.getScope(), t.getModule(), mode);
      CanInlineResult result = injector.canInlineReferenceToFunction(
          ref, fnNode, unsafe,
          NodeUtil.referencesThis(fnNode),
          NodeUtil.containsFunction(NodeUtil.getFunctionBody(fnNode)));
      assertEquals(expectedResult, result);
      return true;
    }
  };

  compiler.resetUniqueNameId();
  TestCallback test = new TestCallback(fnName, tester);
  NodeTraversal.traverseEs6(compiler, tree, test);
}