com.google.javascript.jscomp.UnreachableCodeElimination 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
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.
/*
* Copyright 2008 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.javascript.jscomp.ControlFlowGraph.Branch;
import com.google.javascript.jscomp.graph.DiGraph.DiGraphEdge;
import com.google.javascript.jscomp.graph.DiGraph.DiGraphNode;
import com.google.javascript.jscomp.graph.GraphReachability;
import com.google.javascript.rhino.Node;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Removes dead code from a parse tree. The kinds of dead code that this pass
* removes are:
* - Any code following a return statement, such as the alert
* call in: if (x) { return; alert('unreachable'); }.
* - Statements that have no side effects, such as:
* a.b.MyClass.prototype.propertyName; or true;.
* That first kind of statement sometimes appears intentionally, so that
* prototype properties can be annotated using JSDoc without actually
* being initialized.
*/
// TODO(dimvar): Besides dead code after returns, this pass removes useless live
// code such as breaks/continues/returns and stms w/out side effects.
// These things don't require reachability info, consider making them their own
// pass or putting them in some other, more related pass.
class UnreachableCodeElimination implements CompilerPass {
private static final Logger logger =
Logger.getLogger(UnreachableCodeElimination.class.getName());
private final AbstractCompiler compiler;
private boolean codeChanged;
UnreachableCodeElimination(AbstractCompiler compiler) {
this.compiler = compiler;
}
@Override
public void process(Node externs, Node toplevel) {
checkState(compiler.getLifeCycleStage().isNormalized());
NodeTraversal.traverse(compiler, compiler.getJsRoot(), new EliminationInChangedFunctionsPass());
}
private final class EliminationInChangedFunctionsPass
extends NodeTraversal.AbstractChangedScopeCallback {
@Override
public void enterChangedScopeRoot(AbstractCompiler compiler, Node root) {
// Computes the control flow graph.
ControlFlowGraph cfg =
ControlFlowAnalysis.builder().setCompiler(compiler).setCfgRoot(root).computeCfg();
new GraphReachability<>(cfg).compute(cfg.getEntry().getValue());
if (root.isFunction()) {
root = root.getLastChild();
}
do {
codeChanged = false;
NodeTraversal.traverse(compiler, root, new EliminationPass(cfg));
} while (codeChanged);
}
}
private class EliminationPass implements NodeTraversal.Callback {
private final ControlFlowGraph cfg;
private EliminationPass(ControlFlowGraph cfg) {
this.cfg = cfg;
}
@Override
public boolean shouldTraverse(NodeTraversal nodeTraversal, Node n, Node parent) {
if (parent == null) {
return true;
} else if (n.isExport()) {
// TODO(b/129564961): We should be exploring EXPORTs. We don't because their descendants
// have side-effects that `AstAnalyzer.mayHaveSideEffects` doesn't recognize. Since this
// pass currently runs after exports are removed anyway, this isn't yet an issue.
return false;
} else if (parent.isFunction()) {
// We only want to traverse the name of a function.
return n.isFirstChildOf(parent);
}
return true;
}
@Override
public void visit(NodeTraversal t, Node n, Node parent) {
if (parent == null || n.isFunction() || n.isScript()) {
return;
}
DiGraphNode gNode = cfg.getNode(n);
if (gNode == null) { // Not in CFG.
return;
}
if (gNode.getAnnotation() != GraphReachability.REACHABLE
|| !compiler.getAstAnalyzer().mayHaveSideEffects(n)) {
removeDeadExprStatementSafely(n);
return;
}
tryRemoveUnconditionalBranching(n);
}
/**
* Tries to remove n if it is an unconditional branch node (break, continue,
* or return) and the target of n is the same as the follow of n.
* That is, if removing n preserves the control flow. Also if n targets
* another unconditional branch, this function will recursively try to
* remove the target branch as well. The reason why we want to cascade this
* removal is because we only run this pass once. If we have code such as
*
* break -> break -> break
*
* where all 3 breaks are useless, then the order of removal matters. When
* we first look at the first break, we see that it branches to the 2nd
* break. However, if we remove the last break, the 2nd break becomes
* useless and finally the first break becomes useless as well.
*/
@SuppressWarnings("fallthrough")
private void tryRemoveUnconditionalBranching(Node n) {
/*
* For each unconditional branching control flow node, check to see
* if the ControlFlowAnalysis.computeFollowNode of that node is same as
* the branching target. If it is, the branch node is safe to be removed.
*
* This is not as clever as MinimizeExitPoints because it doesn't do any
* if-else conversion but it handles more complicated switch statements
* much more nicely.
*/
// If n is null the target is the end of the function, nothing to do.
if (n == null) {
return;
}
DiGraphNode gNode = cfg.getNode(n);
if (gNode == null) {
return;
}
switch (n.getToken()) {
case RETURN:
if (n.hasChildren()) {
break;
}
case BREAK:
case CONTINUE:
// We are looking for a control flow changing statement that always
// branches to the same node. If after removing it control still
// branches to the same node, it is safe to remove.
List> outEdges = gNode.getOutEdges();
if (outEdges.size() == 1
&&
// If there is a next node, this jump is not useless.
(n.getNext() == null || n.getNext().isFunction())) {
checkState(outEdges.get(0).getValue() == Branch.UNCOND);
Node fallThrough = computeFollowing(n);
Node nextCfgNode = outEdges.get(0).getDestination().getValue();
if (nextCfgNode == fallThrough && !inFinally(n.getParent(), n)) {
removeNode(n);
}
}
break;
default:
break;
}
}
private boolean inFinally(Node parent, Node child) {
if (parent == null || parent.isFunction()) {
return false;
} else if (NodeUtil.isTryFinallyNode(parent, child)) {
return true;
} else {
return inFinally(parent.getParent(), parent);
}
}
private Node computeFollowing(Node n) {
Node next = ControlFlowAnalysis.computeFollowNode(n);
while (next != null && next.isBlock()) {
if (next.hasChildren()) {
next = next.getFirstChild();
} else {
next = computeFollowing(next);
}
}
return next;
}
private void removeDeadExprStatementSafely(Node n) {
Node parent = n.getParent();
if (n.isEmpty() || (n.isBlock() && !n.hasChildren())) {
// Not always trivial to remove, let FoldConstants work its magic later.
return;
}
// Every expression in a FOR-IN or FOR-OF header looks side effect free on its own.
if (NodeUtil.isEnhancedFor(parent)) {
return;
}
switch (n.getToken()) {
// In the CFG, the only incoming edges of the DO node are from
// breaks/continues and the condition. The edge from the previous
// statement connects directly to the body of the DO.
//
// Removing an unreachable DO node is messy b/c it means we still have
// to execute one iteration of the body. If the DO's body has breaks in
// the middle, it can get even more tricky and code size might actually
// increase.
case DO:
case EXPORT:
return;
case BLOCK:
// BLOCKs are used in several ways including wrapping CATCH
// blocks in TRYs
if (parent.isTry() && NodeUtil.isTryCatchNodeContainer(n)) {
return;
}
break;
case CATCH:
Node tryNode = parent.getParent();
NodeUtil.maybeAddFinally(tryNode);
break;
default:
break;
}
if (n.isVar() && !n.getFirstChild().hasChildren()) {
// Very unlikely case, Consider this:
// File 1: {throw 1}
// File 2: {var x}
// The node var x is unreachable in the global scope.
// Before we remove the node, redeclareVarsInsideBranch
// would basically move var x to the beginning of File 2,
// which resulted in zero changes to the AST but triggered
// reportCodeChange().
// Instead, we should just ignore dead variable declarations.
return;
}
removeNode(n);
}
private void removeNode(Node n) {
codeChanged = true;
NodeUtil.redeclareVarsInsideBranch(n);
compiler.reportChangeToEnclosingScope(n);
if (logger.isLoggable(Level.FINE)) {
logger.fine("Removing " + n);
}
NodeUtil.removeChild(n.getParent(), n);
NodeUtil.markFunctionsDeleted(n, compiler);
}
}
}