com.google.javascript.jscomp.ParenthesizeFunctionsInChunks Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of closure-compiler-unshaded Show documentation

Closure Compiler is a JavaScript optimizing compiler. It parses your JavaScript, analyzes it, removes dead code and rewrites and minimizes what's left. It also checks syntax, variable references, and types, and warns about common JavaScript pitfalls. It is used in many of Google's JavaScript apps, including Gmail, Google Web Search, Google Maps, and Google Docs.

There is a newer version: v20240317

Show newest version

/*
 * Copyright 2022 The Closure Compiler Authors.
 *
 * 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.javascript.jscomp;

import com.google.javascript.jscomp.diagnostic.LogFile;
import com.google.javascript.rhino.IR;
import com.google.javascript.rhino.Node;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Marks all functions of specified chunks for eager parsing by adding the node property
 * Node.MARK_FOR_PARENTHESIZE, which will wrap the fn in ().
 *
 * For non function expressions, we re-write the expression as follows:
 *
 * 

 *   Before: function foo() { ... }
 *   
After: var foo = (function() { ... })
 * 
 *
 * A log file is created 'eager_compile_chunks.log' with output on how many functions were marked
 * for eager compile for each specified chunk.
 */
public final class ParenthesizeFunctionsInChunks implements CompilerPass {
  final AbstractCompiler compiler;
  final Set parenthesizeFunctionsInChunks;

  // Map for recording diagnostic information about what was marked for eager compilation.
  final Map chunkToEagerCompileFnCount = new HashMap<>();

  public ParenthesizeFunctionsInChunks(
      AbstractCompiler compiler, Set parenthesizeFunctionsInChunks) {
    this.compiler = compiler;
    this.parenthesizeFunctionsInChunks = parenthesizeFunctionsInChunks;
  }

  @Override
  public void process(Node externs, Node root) {
    NodeTraversal.traverse(compiler, root, new Traversal());
    for (String key : chunkToEagerCompileFnCount.keySet()) {
      try (LogFile log = compiler.createOrReopenLog(getClass(), "eager_compile_chunks.log")) {
        log.log("%s: %d fn's marked for eager compile", key, chunkToEagerCompileFnCount.get(key));
      }
    }
  }

  private class Traversal implements NodeTraversal.Callback {

    Traversal() {}

    private void rewriteAsFunctionExpression(Node n) {
      Node nameNode = n.getFirstChild();
      Node name = IR.name(nameNode.getString()).srcref(nameNode);
      Node var = IR.var(name).srcref(n);
      // Add the VAR, remove the FUNCTION
      n.replaceWith(var);
      // readd the function, but remove the function name, to guard against
      // functions that re-assign to themselves, which will end up causing a
      // recursive loop.
      n.getFirstChild().setString("");
      name.addChildToFront(n);
    }

    @Override
    public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
      if (n.isScript() || n.isRoot() || n.isModuleBody()) {
        return true;
      }
      if (n.isFunction()) {
        String chunkName = t.getChunk().getName();
        chunkToEagerCompileFnCount.putIfAbsent(chunkName, 0L);
        if (parenthesizeFunctionsInChunks.contains(chunkName)) {
          n.putBooleanProp(Node.MARK_FOR_PARENTHESIZE, true);
          if (!NodeUtil.isFunctionExpression(n)) {
            rewriteAsFunctionExpression(n);
          }
          chunkToEagerCompileFnCount.put(chunkName, chunkToEagerCompileFnCount.get(chunkName) + 1);
        }
        return false;
      }
      return true;
    }

    @Override
    public void visit(NodeTraversal t, Node n, Node parent) {}
  }
}