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

/*
 * Copyright 2016 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 static com.google.common.base.Preconditions.checkState;

import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Multimap;
import com.google.javascript.rhino.Node;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * An optimization pass for J2CL-generated code to hoist some constant assignments out clinit method
 * to declaration phase so they could be used by other optimization passes for static evaluation.
 */
public class J2clConstantHoisterPass implements CompilerPass {

  private final AbstractCompiler compiler;

  J2clConstantHoisterPass(AbstractCompiler compiler) {
    this.compiler = compiler;
  }

  @Override
  public void process(Node externs, Node root) {
    if (!J2clSourceFileChecker.shouldRunJ2clPasses(compiler)) {
      return;
    }

    final Multimap fieldAssignments = ArrayListMultimap.create();
    final Set hoistableFunctions = new HashSet<>();
    NodeTraversal.traversePostOrder(
        compiler,
        root,
        (NodeTraversal t, Node node, Node parent) -> {
          // TODO(stalcup): don't gather assignments ourselves, switch to a persistent
          // DefinitionUseSiteFinder instead.
          if (parent != null && NodeUtil.isLValue(node)) {
            fieldAssignments.put(node.getQualifiedName(), parent);
          }

          // TODO(stalcup): convert to a persistent index of hoistable functions.
          if (isHoistableFunction(t, node)) {
            hoistableFunctions.add(node);
          }
        });

    for (Collection assignments : fieldAssignments.asMap().values()) {
      maybeHoistClassField(assignments, hoistableFunctions);
    }
  }

  /**
   * Returns whether the specified rValue is a function which does not receive any variables from
   * its containing scope, and is thus 'hoistable'.
   */
  private static boolean isHoistableFunction(NodeTraversal t, Node node) {
    // TODO(michaelthomas): This could be improved slightly by not assuming that any variable in the
    // outer scope is used in the function.
    return node.isFunction() && t.getScope().getVarCount() == 0;
  }

  private void maybeHoistClassField(
      Collection assignments, Collection hoistableFunctions) {
    // The field is only assigned twice:
    if (assignments.size() != 2) {
      return;
    }

    Node first = Iterables.get(assignments, 0);
    Node second = Iterables.get(assignments, 1);

    // One of them is the top level declaration and the other is the assignment in clinit.
    Node topLevelDeclaration = isClassFieldDeclaration(first) ? first : second;
    Node clinitAssignment = isClinitFieldAssignment(first) ? first : second;
    if (!isClassFieldDeclaration(topLevelDeclaration)
        || !isClinitFieldAssignment(clinitAssignment)) {
      return;
    }

    // And it is assigned to a literal value; hence could be used in static eval and safe to move:
    Node assignmentRhs = clinitAssignment.getSecondChild();
    if (!NodeUtil.isLiteralValue(assignmentRhs, true /* includeFunctions */)
        || (assignmentRhs.isFunction() && !hoistableFunctions.contains(assignmentRhs))) {
      return;
    }

    // And the assignment are in the same script:
    if (NodeUtil.getEnclosingScript(clinitAssignment)
        != NodeUtil.getEnclosingScript(topLevelDeclaration)) {
      return;
    }

    // At this point the only case some could observe the declaration value is the when you have
    // cycle between clinits and the field is accessed before initialization; which is almost always
    // a bug and GWT never assumed this state is observable in its optimization, yet nobody
    // complained. So it is safe to upgrade it to a constant.
    hoistConstantLikeField(clinitAssignment, topLevelDeclaration);
  }

  private void hoistConstantLikeField(Node clinitAssignment, Node topLevelDeclaration) {
    Node clinitAssignedValue = clinitAssignment.getSecondChild();
    Node declarationInClass = topLevelDeclaration.getFirstChild();
    Node declarationAssignedValue = declarationInClass.getFirstChild();

    Node clinitChangeScope = NodeUtil.getEnclosingChangeScopeRoot(clinitAssignment);
    // Remove the clinit initialization
    NodeUtil.removeChild(clinitAssignment.getParent(), clinitAssignment);


    clinitAssignedValue.detach();
    compiler.reportChangeToChangeScope(clinitChangeScope);
    if (declarationAssignedValue == null) {
      // Add the value from clinit to the stub declaration
      declarationInClass.addChildToFront(clinitAssignedValue);
      compiler.reportChangeToEnclosingScope(topLevelDeclaration);
    } else if (!declarationAssignedValue.isEquivalentTo(clinitAssignedValue)) {
      checkState(NodeUtil.isLiteralValue(declarationAssignedValue, false /* includeFunctions */));
      // Replace the assignment in declaration with the value from clinit
      declarationInClass.replaceChild(declarationAssignedValue, clinitAssignedValue);
      compiler.reportChangeToEnclosingScope(topLevelDeclaration);
    }
    declarationInClass.putBooleanProp(Node.IS_CONSTANT_VAR, true);
  }

  /**
   * Matches literal value declarations {@code var foo = 3;} or stub declarations like
   * {@code var bar;}.
   */
  private static boolean isClassFieldDeclaration(Node node) {
    return node.getParent().isScript()
        && node.isVar()
        && (!node.getFirstChild().hasChildren()
            || (node.getFirstFirstChild() != null
                && NodeUtil.isLiteralValue(
                    node.getFirstFirstChild(), false /* includeFunctions */)));
  }

  private static boolean isClinitFieldAssignment(Node node) {
    return node.getParent().isExprResult()
        && node.getGrandparent().isNormalBlock()
        && isClinitMethod(node.getGrandparent().getParent());
  }

  // TODO(goktug): Create a utility to share this logic and start using getQualifiedOriginalName.
  private static boolean isClinitMethod(Node fnNode) {
    if (!fnNode.isFunction()) {
      return false;
    }

    String fnName = NodeUtil.getName(fnNode);
    return fnName != null && isClinitMethodName(fnName);
  }

  private static boolean isClinitMethodName(String methodName) {
    return methodName != null
        && (methodName.endsWith("$$0clinit") || methodName.endsWith(".$clinit"));
  }
}