| /* |
| * Copyright 2009 Google Inc. |
| * |
| * 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.gwt.dev.js; |
| |
| import com.google.gwt.dev.cfg.ConfigurationProperties; |
| import com.google.gwt.dev.cfg.PermutationProperties; |
| import com.google.gwt.dev.jjs.HasSourceInfo; |
| import com.google.gwt.dev.jjs.SourceInfo; |
| import com.google.gwt.dev.jjs.ast.JDeclaredType; |
| import com.google.gwt.dev.jjs.ast.JMethod; |
| import com.google.gwt.dev.jjs.ast.JProgram; |
| import com.google.gwt.dev.jjs.ast.RuntimeConstants; |
| import com.google.gwt.dev.jjs.impl.JavaToJavaScriptMap; |
| import com.google.gwt.dev.js.ast.HasArguments; |
| import com.google.gwt.dev.js.ast.HasName; |
| import com.google.gwt.dev.js.ast.JsArrayAccess; |
| import com.google.gwt.dev.js.ast.JsArrayLiteral; |
| import com.google.gwt.dev.js.ast.JsBinaryOperation; |
| import com.google.gwt.dev.js.ast.JsBinaryOperator; |
| import com.google.gwt.dev.js.ast.JsBlock; |
| import com.google.gwt.dev.js.ast.JsBooleanLiteral; |
| import com.google.gwt.dev.js.ast.JsCatch; |
| import com.google.gwt.dev.js.ast.JsContext; |
| import com.google.gwt.dev.js.ast.JsExprStmt; |
| import com.google.gwt.dev.js.ast.JsExpression; |
| import com.google.gwt.dev.js.ast.JsFor; |
| import com.google.gwt.dev.js.ast.JsFunction; |
| import com.google.gwt.dev.js.ast.JsInvocation; |
| import com.google.gwt.dev.js.ast.JsModVisitor; |
| import com.google.gwt.dev.js.ast.JsName; |
| import com.google.gwt.dev.js.ast.JsNameRef; |
| import com.google.gwt.dev.js.ast.JsNew; |
| import com.google.gwt.dev.js.ast.JsNode; |
| import com.google.gwt.dev.js.ast.JsNullLiteral; |
| import com.google.gwt.dev.js.ast.JsNumberLiteral; |
| import com.google.gwt.dev.js.ast.JsPostfixOperation; |
| import com.google.gwt.dev.js.ast.JsPrefixOperation; |
| import com.google.gwt.dev.js.ast.JsProgram; |
| import com.google.gwt.dev.js.ast.JsPropertyInitializer; |
| import com.google.gwt.dev.js.ast.JsReturn; |
| import com.google.gwt.dev.js.ast.JsRootScope; |
| import com.google.gwt.dev.js.ast.JsStatement; |
| import com.google.gwt.dev.js.ast.JsStringLiteral; |
| import com.google.gwt.dev.js.ast.JsThrow; |
| import com.google.gwt.dev.js.ast.JsTry; |
| import com.google.gwt.dev.js.ast.JsUnaryOperation; |
| import com.google.gwt.dev.js.ast.JsUnaryOperator; |
| import com.google.gwt.dev.js.ast.JsVars; |
| import com.google.gwt.dev.js.ast.JsVars.JsVar; |
| import com.google.gwt.dev.js.ast.JsVisitor; |
| import com.google.gwt.dev.js.ast.JsWhile; |
| import com.google.gwt.dev.util.collect.Lists; |
| import com.google.gwt.dev.util.collect.Maps; |
| |
| import java.io.File; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Emulates the JS stack in order to provide useful stack traces on browsers that |
| * do not provide useful stack information. |
| * |
| * @see com.google.gwt.core.client.impl.StackTraceCreator |
| */ |
| public class JsStackEmulator { |
| |
| /** |
| * Resets the global stack depth to the local stack index and top stack frame |
| * after calls to Exceptions.toJava. This is created by |
| * {@link EntryExitVisitor#visit(JsCatch, JsContext)}. |
| */ |
| private class CatchStackReset extends JsModVisitor { |
| |
| /** |
| * The local stackIndex variable in the function. |
| */ |
| private final EntryExitVisitor eeVisitor; |
| |
| public CatchStackReset(EntryExitVisitor eeVisitor) { |
| this.eeVisitor = eeVisitor; |
| } |
| |
| @Override |
| public void endVisit(JsExprStmt x, JsContext ctx) { |
| if (!isExceptionWrappingCode(x)) { |
| return; |
| } |
| |
| // $stackDepth = stackIndex |
| SourceInfo info = x.getSourceInfo(); |
| JsBinaryOperation reset = new JsBinaryOperation(info, |
| JsBinaryOperator.ASG, stackDepth.makeRef(info), |
| eeVisitor.stackIndexRef(info)); |
| |
| ctx.insertAfter(reset.makeStmt()); |
| } |
| } |
| |
| private boolean isExceptionWrappingCode(JsExprStmt x) { |
| // Looking for e = Exceptions.toJava(e); |
| JsExpression expr = x.getExpression(); |
| |
| if (!(expr instanceof JsBinaryOperation)) { |
| return false; |
| } |
| |
| JsBinaryOperation op = (JsBinaryOperation) expr; |
| if (!(op.getArg2() instanceof JsInvocation)) { |
| return false; |
| } |
| |
| JsInvocation i = (JsInvocation) op.getArg2(); |
| JsExpression q = i.getQualifier(); |
| if (!(q instanceof JsNameRef)) { |
| return false; |
| } |
| |
| JsName name = ((JsNameRef) q).getName(); |
| if (name == null) { |
| return false; |
| } |
| |
| // caughtFunction is the JsFunction translated from Exceptions.toJava |
| if (name != wrapFunctionName) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * The EntryExitVisitor handles pushing and popping frames onto the emulated |
| * stack. It will operate on exactly one JsFunction. The basic transformation |
| * is to add a push operation at every function entry, and then a pop |
| * operation for every statement that might be the final statement executed by |
| * the function. |
| * <p> |
| * General stack depth entry/exit code: |
| * |
| * <pre> |
| * function foo() { |
| * var stackIndex; |
| * $stack[stackIndex = ++$stackDepth] = foo; |
| * |
| * ... do stuff .. |
| * |
| * $stackDepth = stackIndex - 1; |
| * } |
| * </pre> |
| * <p> |
| * For more complicated control flows involving return statements in try |
| * blocks with as associated finally block, it is necessary to introduce a |
| * local variable to indicate if control flow is expected to terminate |
| * normally at the end of the finally block: |
| * |
| * <pre> |
| * var exitingEarly; |
| * try { |
| * if (...) { |
| * return (exitingEarly = true, new Foo()); |
| * } |
| * ... |
| * } finally { |
| * ... existing finally code .. |
| * exitingEarly && $stackDepth = stackIndex - 1; |
| * } |
| * </pre> |
| * A separate local variable is used for each try/finally nested within a |
| * finally block. |
| * <p> |
| * Try statements without a catch block will have a catch block added to them |
| * so that catch blocks are the only places where flow-control may jump to. |
| * All catch blocks are altered so that the global $stackDepth variable is |
| * reset to the local stack index value. This allows browser-native exceptions |
| * to be created with the correct stack trace before the finally code is |
| * executed with a correct stack depth. |
| * |
| * <pre> |
| * try { |
| * foo(); |
| * } finally { |
| * bar(); |
| * } |
| * </pre> |
| * |
| * becomes |
| * |
| * <pre> |
| * try { |
| * foo(); |
| * } catch (e) { |
| * e = Exceptions.toJava(e); |
| * $stackDepth = stackIndex; |
| * throw e; |
| * } finally { |
| * bar(); |
| * } |
| * <p> |
| * Note that there is no specific handling for explicit throw statements, as |
| * the stack instrumentation must also handle browser-generated exceptions |
| * (e.g. <code>null.a()</code>). |
| */ |
| private class EntryExitVisitor extends JsModVisitor { |
| |
| /** |
| * The name of a function-local variable to hold the invocation's slot in |
| * the stack. |
| */ |
| protected JsName stackIndex; |
| |
| private final JsFunction currentFunction; |
| |
| /** |
| * Maps finally blocks to the local variable name which is used to indicate |
| * if that finally block will exit the function early. This is a map and not |
| * a single value because a finally block might be nested in another exit |
| * block. |
| */ |
| private Map<JsBlock, JsName> finallyBlocksToExitVariables = Maps.create(); |
| |
| /** |
| * This variable will indicate the finally block that contains the last |
| * statement that will be executed if an unconditional flow control change |
| * were to occur within the associated try block. |
| */ |
| private JsBlock outerFinallyBlock; |
| |
| /** |
| * Used if a return statement's expression could potentially trigger an |
| * exception. |
| */ |
| private JsName returnTemp; |
| |
| /** |
| * Final cleanup for any new local variables that need to be created. |
| */ |
| private List<JsVar> varsToAdd = Lists.create(); |
| |
| public EntryExitVisitor(JsFunction currentFunction) { |
| this.currentFunction = currentFunction; |
| } |
| |
| /** |
| * If the visitor is exiting the current function's block, add additional |
| * local variables and the final stack-pop instructions. |
| */ |
| @Override |
| public void endVisit(JsBlock x, JsContext ctx) { |
| if (x == currentFunction.getBody()) { |
| |
| // Add the entry code |
| List<JsStatement> statements = x.getStatements(); |
| int idx = statements.isEmpty() |
| || !(statements.get(0) instanceof JsVars) ? 0 : 1; |
| |
| // Add push and pop statements |
| statements.add(idx, push(currentFunction)); |
| addPopAtEndOfBlock(x, false); |
| |
| // Add any needed variables |
| JsVars vars; |
| if (statements.get(0) instanceof JsVars) { |
| vars = (JsVars) statements.get(0); |
| } else { |
| vars = new JsVars(currentFunction.getSourceInfo()); |
| statements.add(0, vars); |
| } |
| for (JsVar var : varsToAdd) { |
| vars.add(var); |
| } |
| } |
| } |
| |
| @Override |
| public void endVisit(JsReturn x, JsContext ctx) { |
| if (outerFinallyBlock != null) { |
| // There is a finally block, so we need to set the early-exit flag |
| JsBinaryOperation asg = new JsBinaryOperation(x.getSourceInfo(), |
| JsBinaryOperator.ASG, earlyExitRef(outerFinallyBlock), |
| JsBooleanLiteral.get(true)); |
| if (x.getExpr() == null) { |
| if (ctx.canInsert()) { |
| // exitingEarly = true; return; |
| ctx.insertBefore(asg.makeStmt()); |
| } else { |
| // {exitingEarly = true; return;} |
| JsBlock block = new JsBlock(x.getSourceInfo()); |
| block.getStatements().add(asg.makeStmt()); |
| block.getStatements().add(x); |
| ctx.replaceMe(block); |
| } |
| } else { |
| // return (exitingEarly = true, expr); |
| JsBinaryOperation op = new JsBinaryOperation(x.getSourceInfo(), |
| JsBinaryOperator.COMMA, asg, x.getExpr()); |
| x.setExpr(op); |
| } |
| } else { |
| if (x.getExpr() != null && x.getExpr().hasSideEffects()) { |
| // temp = expr; pop(); return temp; |
| SourceInfo info = x.getSourceInfo(); |
| JsBinaryOperation asg = new JsBinaryOperation(info, |
| JsBinaryOperator.ASG, returnTempRef(info), x.getExpr()); |
| x.setExpr(returnTempRef(info)); |
| pop(x, asg, ctx); |
| } else { |
| // Otherwise, pop the stack frame |
| pop(x, null, ctx); |
| } |
| } |
| } |
| |
| /** |
| * We want to look at unaltered versions of the catch block, so this is a |
| * <code>visit<code> and not a <code>endVisit</code>. |
| */ |
| @Override |
| public boolean visit(JsCatch x, JsContext ctx) { |
| // Reset the stack depth to the local index |
| new CatchStackReset(this).accept(x); |
| return true; |
| } |
| |
| @Override |
| public boolean visit(JsFunction x, JsContext ctx) { |
| // Will be taken care of by the Bootstrap visitor |
| return false; |
| } |
| |
| @Override |
| public boolean visit(JsTry x, JsContext ctx) { |
| |
| /* |
| * Only the outermost finally block needs special treatment; try/finally |
| * block within try blocks do not receive special treatment. |
| */ |
| JsBlock finallyBlock = x.getFinallyBlock(); |
| if (finallyBlock != null && outerFinallyBlock == null) { |
| outerFinallyBlock = finallyBlock; |
| |
| // Manual traversal |
| accept(x.getTryBlock()); |
| |
| if (x.getCatches().isEmpty()) { |
| JsCatch c = makeSyntheticCatchBlock(x); |
| x.getCatches().add(c); |
| } |
| assert x.getCatches().size() >= 1; |
| acceptList(x.getCatches()); |
| |
| // Exceptions in the finally block just exit the function |
| assert outerFinallyBlock == finallyBlock; |
| outerFinallyBlock = null; |
| accept(finallyBlock); |
| |
| // Stack-pop instruction |
| addPopAtEndOfBlock(finallyBlock, true); |
| |
| // Clean up entry after adding pop instruction |
| finallyBlocksToExitVariables = Maps.remove( |
| finallyBlocksToExitVariables, finallyBlock); |
| return false; |
| } |
| |
| // Normal visit |
| return true; |
| } |
| |
| /** |
| * Create a reference to the function-local stack index variable, possibly |
| * allocating it. |
| */ |
| protected JsNameRef stackIndexRef(SourceInfo info) { |
| if (stackIndex == null) { |
| stackIndex = currentFunction.getScope().declareName( |
| "JsStackEmulator_stackIndex", "stackIndex"); |
| |
| JsVar var = new JsVar(info, stackIndex); |
| varsToAdd = Lists.add(varsToAdd, var); |
| } |
| return stackIndex.makeRef(info); |
| } |
| |
| /** |
| * Code-gen function for generating the stack-pop statement at the end of a |
| * block. A no-op if the last statement is a <code>throw</code> or |
| * <code>return</code> statement, since it will have already caused a pop |
| * statement to have been added. |
| * |
| * @param checkEarlyExit if <code>true</code>, generates |
| * <code>earlyExit && pop()</code> |
| */ |
| private void addPopAtEndOfBlock(JsBlock x, boolean checkEarlyExit) { |
| JsStatement last = x.getStatements().isEmpty() ? null |
| : x.getStatements().get(x.getStatements().size() - 1); |
| if (last instanceof JsReturn || last instanceof JsThrow) { |
| /* |
| * Don't need a pop after a throw or break statement. This is an |
| * optimization for the common case of returning a value as the last |
| * statement, but doesn't cover all flow-control cases. |
| */ |
| return; |
| } else if (checkEarlyExit && !finallyBlocksToExitVariables.containsKey(x)) { |
| /* |
| * No early-exit variable was ever allocated for this block. This means |
| * that the variable can never be true, and thus the stack-popping |
| * expression will never be executed. |
| */ |
| return; |
| } |
| |
| // pop() |
| SourceInfo info = x.getSourceInfo(); |
| JsExpression op = pop(info); |
| |
| if (checkEarlyExit) { |
| // earlyExit && pop() |
| op = new JsBinaryOperation(info, JsBinaryOperator.AND, earlyExitRef(x), |
| op); |
| } |
| |
| x.getStatements().add(op.makeStmt()); |
| } |
| |
| /** |
| * Generate a name reference to the early-exit variable for a given block, |
| * possibly allocating a new variable. |
| */ |
| private JsNameRef earlyExitRef(JsBlock x) { |
| JsName earlyExitName = finallyBlocksToExitVariables.get(x); |
| if (earlyExitName == null) { |
| earlyExitName = currentFunction.getScope().declareName( |
| "JsStackEmulator_exitingEarly" |
| + finallyBlocksToExitVariables.size(), "exitingEarly"); |
| |
| finallyBlocksToExitVariables = Maps.put(finallyBlocksToExitVariables, |
| x, earlyExitName); |
| JsVar var = new JsVar(x.getSourceInfo(), earlyExitName); |
| varsToAdd = Lists.add(varsToAdd, var); |
| } |
| return earlyExitName.makeRef(x.getSourceInfo()); |
| } |
| |
| private JsCatch makeSyntheticCatchBlock(JsTry x) { |
| /* |
| * catch (e) { e = Exceptions.toJava(e); throw Exceptions.toJs(e); } |
| */ |
| SourceInfo info = x.getSourceInfo(); |
| |
| JsCatch c = new JsCatch(info, currentFunction.getScope(), "e"); |
| JsName paramName = c.getParameter().getName(); |
| |
| // Exceptiobs.toJava(e) |
| JsInvocation wrapCall = new JsInvocation(info, wrapFunctionName.makeRef(info), |
| paramName.makeRef(info)); |
| |
| // e = Exceptions.toJava(e) |
| JsBinaryOperation asg = new JsBinaryOperation(info, JsBinaryOperator.ASG, |
| paramName.makeRef(info), wrapCall); |
| |
| // Exceptions.toJs(e) |
| JsInvocation unwrapCall = |
| new JsInvocation(info, unwrapFunctionName.makeRef(info), paramName.makeRef(info)); |
| |
| // throw Exceptions.toJs(e) |
| JsThrow throwStatement = new JsThrow(info, unwrapCall); |
| |
| JsBlock body = new JsBlock(info); |
| body.getStatements().add(asg.makeStmt()); |
| body.getStatements().add(throwStatement); |
| c.setBody(body); |
| return c; |
| } |
| |
| /** |
| * Pops the stack frame. |
| */ |
| private void pop(JsStatement x, JsExpression expr, JsContext ctx) { |
| // $stackDepth = stackIndex - 1 |
| SourceInfo info = x.getSourceInfo(); |
| |
| JsExpression op = pop(info); |
| |
| if (ctx.canInsert()) { |
| if (expr != null) { |
| ctx.insertBefore(expr.makeStmt()); |
| } |
| ctx.insertBefore(op.makeStmt()); |
| } else { |
| JsBlock block = new JsBlock(info); |
| if (expr != null) { |
| block.getStatements().add(expr.makeStmt()); |
| } |
| block.getStatements().add(op.makeStmt()); |
| block.getStatements().add(x); |
| ctx.replaceMe(block); |
| } |
| } |
| |
| /** |
| * Decrement the $stackDepth variable. |
| */ |
| private JsExpression pop(SourceInfo info) { |
| JsBinaryOperation sub = new JsBinaryOperation(info, JsBinaryOperator.SUB, |
| stackIndexRef(info), new JsNumberLiteral(info, 1)); |
| JsBinaryOperation op = new JsBinaryOperation(info, JsBinaryOperator.ASG, |
| stackDepth.makeRef(info), sub); |
| return op; |
| } |
| |
| /** |
| * Create the function-entry code. |
| */ |
| private JsStatement push(HasSourceInfo x) { |
| SourceInfo info = x.getSourceInfo(); |
| |
| JsNameRef stackRef = stack.makeRef(info); |
| JsNameRef stackDepthRef = stackDepth.makeRef(info); |
| JsExpression currentFunctionRef; |
| if (currentFunction.getName() == null) { |
| // Anonymous |
| currentFunctionRef = JsNullLiteral.INSTANCE; |
| } else { |
| currentFunctionRef = currentFunction.getName().makeRef(info); |
| } |
| |
| // ++stackDepth |
| JsUnaryOperation inc = new JsPrefixOperation(info, JsUnaryOperator.INC, |
| stackDepthRef); |
| |
| // stackIndex = ++stackDepth |
| JsBinaryOperation stackIndexOp = new JsBinaryOperation(info, |
| JsBinaryOperator.ASG, stackIndexRef(info), inc); |
| |
| // stack[stackIndex = ++stackDepth] |
| JsArrayAccess access = new JsArrayAccess(info, stackRef, stackIndexOp); |
| |
| // stack[stackIndex = ++stackDepth] = currentFunction |
| JsBinaryOperation op = new JsBinaryOperation(info, JsBinaryOperator.ASG, |
| access, currentFunctionRef); |
| |
| return op.makeStmt(); |
| } |
| |
| private JsNameRef returnTempRef(SourceInfo info) { |
| if (returnTemp == null) { |
| returnTemp = currentFunction.getScope().declareName( |
| "JsStackEmulator_returnTemp", "returnTemp"); |
| |
| JsVar var = new JsVar(info, returnTemp); |
| varsToAdd = Lists.add(varsToAdd, var); |
| } |
| return returnTemp.makeRef(info); |
| } |
| } |
| |
| /** |
| * Creates a visitor to instrument each JsFunction in the jsProgram. |
| */ |
| private class InstrumentAllFunctions extends JsVisitor { |
| |
| @Override |
| public void endVisit(JsFunction x, JsContext ctx) { |
| if (x.getBody().getStatements().isEmpty() || |
| !shouldInstrumentFunction(x)) { |
| return; |
| } |
| |
| if (recordLineNumbers) { |
| (new LocationVisitor(x)).accept(x.getBody()); |
| } else { |
| (new EntryExitVisitor(x)).accept(x.getBody()); |
| } |
| } |
| } |
| |
| /** |
| * Extends EntryExit visitor to record location information in the AST. This |
| * visitor will modify every JsExpression that can potentially result in a |
| * change of flow control with file and line number data. |
| * <p> |
| * This simply generates code to set entries in the <code>$location</code> |
| * stack, parallel to <code>$stack</code>: |
| * |
| * <pre> |
| * ($location[stackIndex] = 'Foo.java:' + 42, expr); |
| * </pre> |
| * |
| * Inclusion of file names is dependent on the value of the |
| * {@link JsStackEmulator#recordFileNames} field. |
| */ |
| private class LocationVisitor extends EntryExitVisitor { |
| private String lastFile; |
| private int lastLine; |
| |
| /** |
| * Nodes in this set are used in a context that expects a reference, not |
| * just an arbitrary expression. For example, <code>delete</code> takes a |
| * reference. These are tracked because it wouldn't be safe to rewrite |
| * <code>delete foo.bar</code> to <code>delete (line='123',foo).bar</code>. |
| */ |
| private final Set<JsNode> nodesInRefContext = new HashSet<JsNode>(); |
| |
| public LocationVisitor(JsFunction function) { |
| super(function); |
| clearLocation(); |
| } |
| |
| @Override |
| public void endVisit(JsArrayAccess x, JsContext ctx) { |
| record(x, ctx); |
| } |
| |
| @Override |
| public void endVisit(JsBinaryOperation x, JsContext ctx) { |
| if (x.getOperator().isAssignment()) { |
| record(x, ctx); |
| } |
| } |
| |
| @Override |
| public void endVisit(JsInvocation x, JsContext ctx) { |
| nodesInRefContext.remove(x.getQualifier()); |
| |
| // Record the location as close as possible to calling the function. |
| List<JsExpression> args = x.getArguments(); |
| if (!args.isEmpty()) { |
| recordAfterLastArg(x); |
| return; |
| } |
| |
| JsNameRef qualifier = getPossibleMethod(x); |
| if (qualifier == null) { |
| record(x, ctx); |
| return; |
| } |
| |
| // This is a call using a qualified name like foo.bar() |
| // Record the location after evaluating foo. |
| // (Doing it after evaluating .bar causes lots of tests to fail.) |
| |
| SourceInfo locationToRecord = x.getSourceInfo(); |
| if (sameAsLastLocation(locationToRecord)) { |
| return; |
| } |
| |
| qualifier.setQualifier(recordAfter(qualifier.getQualifier(), locationToRecord)); |
| setLastLocation(locationToRecord); |
| didChange = true; |
| } |
| |
| @Override |
| public void endVisit(JsNameRef x, JsContext ctx) { |
| record(x, ctx); |
| } |
| |
| @Override |
| public void endVisit(JsNew x, JsContext ctx) { |
| nodesInRefContext.remove(x.getConstructorExpression()); |
| |
| // Record the location as close as possible to calling the constructor. |
| |
| if (!x.getArguments().isEmpty()) { |
| recordAfterLastArg(x); |
| } else { |
| record(x, ctx); |
| } |
| } |
| |
| @Override |
| public void endVisit(JsPostfixOperation x, JsContext ctx) { |
| record(x, ctx); |
| } |
| |
| @Override |
| public void endVisit(JsPrefixOperation x, JsContext ctx) { |
| record(x, ctx); |
| nodesInRefContext.remove(x.getArg()); |
| } |
| |
| @Override |
| public boolean visit(JsExprStmt x, JsContext ctx) { |
| if (isExceptionWrappingCode(x)) { |
| // Don't instrument exception wrapping code. |
| return false; |
| } |
| return true; |
| } |
| /** |
| * This is essentially a hacked-up version of JsFor.traverse to account for |
| * flow control differing from visitation order. It resets lastFile and |
| * lastLine before the condition and increment expressions in the for loop |
| * so that location data will be recorded correctly. |
| */ |
| @Override |
| public boolean visit(JsFor x, JsContext ctx) { |
| if (x.getInitExpr() != null) { |
| x.setInitExpr(accept(x.getInitExpr())); |
| } else if (x.getInitVars() != null) { |
| x.setInitVars(accept(x.getInitVars())); |
| } |
| |
| if (x.getCondition() != null) { |
| clearLocation(); |
| x.setCondition(accept(x.getCondition())); |
| } |
| |
| if (x.getIncrExpr() != null) { |
| clearLocation(); |
| x.setIncrExpr(accept(x.getIncrExpr())); |
| } |
| |
| accept(x.getBody()); |
| return false; |
| } |
| |
| @Override |
| public boolean visit(JsInvocation x, JsContext ctx) { |
| nodesInRefContext.add(x.getQualifier()); |
| return true; |
| } |
| |
| @Override |
| public boolean visit(JsNew x, JsContext ctx) { |
| nodesInRefContext.add(x.getConstructorExpression()); |
| return true; |
| } |
| |
| @Override |
| public boolean visit(JsPrefixOperation x, JsContext ctx) { |
| if (x.getOperator() == JsUnaryOperator.DELETE |
| || x.getOperator() == JsUnaryOperator.TYPEOF) { |
| nodesInRefContext.add(x.getArg()); |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean visit(JsPropertyInitializer x, JsContext ctx) { |
| // do not instrument left hand side of initializer. |
| x.setValueExpr(accept(x.getValueExpr())); |
| return false; |
| } |
| |
| /** |
| * Similar to JsFor, this resets the current location information before |
| * evaluating the condition. |
| */ |
| @Override |
| public boolean visit(JsWhile x, JsContext ctx) { |
| clearLocation(); |
| x.setCondition(accept(x.getCondition())); |
| accept(x.getBody()); |
| return false; |
| } |
| |
| /** |
| * If the invocation might be a method call, return its NameRef. |
| * Otherwise, return null. |
| */ |
| private JsNameRef getPossibleMethod(JsInvocation x) { |
| if (!(x.getQualifier() instanceof JsNameRef)) { |
| return null; |
| } |
| JsNameRef ref = (JsNameRef) x.getQualifier(); |
| if (ref.getQualifier() == null) { |
| return null; |
| } |
| return ref; |
| } |
| |
| /** |
| * Strips off the final name segment. |
| */ |
| private String baseName(String fileName) { |
| // Try the system path separator |
| int lastIndex = fileName.lastIndexOf(File.separator); |
| if (lastIndex == -1) { |
| // Otherwise, try URL path separator |
| lastIndex = fileName.lastIndexOf('/'); |
| } |
| if (lastIndex != -1) { |
| return fileName.substring(lastIndex + 1); |
| } else { |
| return fileName; |
| } |
| } |
| |
| /** |
| * Given an expression and its context, record the location before |
| * evaluating the expression, under the following conditions: |
| * |
| * - We are in a context where this is allowed. |
| * - we have not previously called record() with the same location. |
| * |
| * Note that record() must be called in the same order that the expressions |
| * will be evaluated at runtime. When this isn't true, {@link #clearLocation} |
| * must be called first. |
| * |
| * Side-effect: updates lastLine and possibly lastFile. |
| */ |
| private void record(JsExpression x, JsContext ctx) { |
| |
| if (ctx.isLvalue()) { |
| // Assignments to comma expressions aren't legal |
| return; |
| } else if (nodesInRefContext.contains(x)) { |
| // Don't modify references into non-references |
| return; |
| } |
| |
| SourceInfo locationToRecord = x.getSourceInfo(); |
| if (sameAsLastLocation(locationToRecord)) { |
| return; // no change |
| } |
| |
| JsBinaryOperation comma = new JsBinaryOperation(locationToRecord, JsBinaryOperator.COMMA, |
| assignLocation(locationToRecord), x); |
| ctx.replaceMe(comma); |
| |
| setLastLocation(locationToRecord); |
| } |
| |
| /** |
| * Records the position after evaluating the last argument. |
| * This must be called after visiting the arguments. |
| * |
| * Side-effect: updates lastLine and possibly lastFile. |
| */ |
| private <T extends JsExpression & HasArguments> void recordAfterLastArg(T x) { |
| SourceInfo locationToRecord = x.getSourceInfo(); |
| if (sameAsLastLocation(locationToRecord)) { |
| return; // no change |
| } |
| List<JsExpression> args = x.getArguments(); |
| JsExpression last = args.get(args.size() - 1); |
| args.set(args.size() - 1, recordAfter(last, locationToRecord)); |
| setLastLocation(locationToRecord); |
| didChange = true; |
| } |
| |
| /** |
| * Sets the last location recorded. (Used to avoid repeating the same location |
| * in the next call to {@link #record}.) |
| */ |
| private void setLastLocation(SourceInfo recordedLocation) { |
| lastLine = recordedLocation.getStartLine(); |
| if (recordFileNames) { |
| lastFile = recordedLocation.getFileName(); |
| } |
| } |
| |
| /** |
| * Ensures that the next call to record() will record the location. |
| */ |
| private void clearLocation() { |
| lastFile = ""; |
| lastLine = -1; |
| } |
| |
| private boolean sameAsLastLocation(SourceInfo info) { |
| return info.getStartLine() == lastLine |
| && (!recordFileNames || info.getFileName().equals(lastFile)); |
| } |
| |
| /** |
| * Wrap an expression so that we record a location after evaluating it. |
| * (Requires a temporary variable.) |
| */ |
| private JsExpression recordAfter(JsExpression x, SourceInfo locationToRecord) { |
| // ($tmp = x, $locations[stackIndex] = "{fileName}:" + "{lineNumber}", $tmp) |
| SourceInfo info = x.getSourceInfo(); |
| JsExpression setTmp = new JsBinaryOperation(info, JsBinaryOperator.ASG, tmp.makeRef(info), x); |
| return new JsBinaryOperation(info, JsBinaryOperator.COMMA, |
| new JsBinaryOperation(info, JsBinaryOperator.COMMA, setTmp, |
| assignLocation(locationToRecord)), |
| tmp.makeRef(info)); |
| } |
| |
| /** |
| * Returns an expression that assigns the location. |
| */ |
| private JsExpression assignLocation(SourceInfo info) { |
| // If filenames are on: |
| // $locations[stackIndex] = "{fileName}:" + "{lineNumber}"; |
| // Otherwise: |
| // $locations[stackIndex] = "{lineNumber}"; |
| |
| JsExpression location = new JsStringLiteral(info, String.valueOf(info.getStartLine())); |
| if (recordFileNames) { |
| // 'fileName:' + lineNumber |
| JsStringLiteral stringLit = new JsStringLiteral(info, baseName(info.getFileName()) + ":"); |
| location = new JsBinaryOperation(info, JsBinaryOperator.ADD, stringLit, location); |
| } |
| |
| JsArrayAccess access = new JsArrayAccess(info, lineNumbers.makeRef(info), |
| stackIndexRef(info)); |
| return new JsBinaryOperation(info, JsBinaryOperator.ASG, access, location); |
| } |
| } |
| |
| /** |
| * The StackTraceCreator code refers to identifiers defined in JsRootScope, |
| * which are unobfuscatable. This visitor replaces references to those symbols |
| * with references to our locally-defined, obfuscatable names. |
| */ |
| private class ReplaceUnobfuscatableNames extends JsModVisitor { |
| // See JsRootScope for the definition of these names |
| private final JsName rootLineNumbers = |
| JsRootScope.INSTANCE.findExistingUnobfuscatableName("$location"); |
| private final JsName rootStack = |
| JsRootScope.INSTANCE.findExistingUnobfuscatableName("$stack"); |
| private final JsName rootStackDepth = |
| JsRootScope.INSTANCE.findExistingUnobfuscatableName("$stackDepth"); |
| |
| @Override |
| public void endVisit(JsNameRef x, JsContext ctx) { |
| JsName name = x.getName(); |
| JsNameRef newRef = null; |
| |
| if (name == rootStack) { |
| newRef = stack.makeRef(x.getSourceInfo()); |
| } else if (name == rootStackDepth) { |
| newRef = stackDepth.makeRef(x.getSourceInfo()); |
| } else if (name == rootLineNumbers) { |
| newRef = lineNumbers.makeRef(x.getSourceInfo()); |
| } |
| |
| if (newRef == null) { |
| return; |
| } |
| |
| assert x.getQualifier() == null; |
| ctx.replaceMe(newRef); |
| } |
| } |
| |
| /** |
| * Corresponds to property compiler.stackMode in EmulateJsStack.gwt.xml |
| * module. |
| */ |
| public enum StackMode { |
| STRIP, NATIVE, EMULATED |
| } |
| |
| public static void exec(JProgram jprogram, JsProgram jsProgram, PermutationProperties properties, |
| JavaToJavaScriptMap jjsmap) { |
| if (getStackMode(properties) == StackMode.EMULATED) { |
| new JsStackEmulator(jprogram, jsProgram, jjsmap, properties.getConfigurationProperties()) |
| .execImpl(); |
| } |
| } |
| |
| public static StackMode getStackMode(PermutationProperties properties) { |
| String value = properties.mustGetString("compiler.stackMode"); |
| return StackMode.valueOf(value.toUpperCase(Locale.ROOT)); |
| } |
| |
| private JsName wrapFunctionName; |
| private JsName unwrapFunctionName; |
| private JsName lineNumbers; |
| private JProgram jprogram; |
| private final JsProgram jsProgram; |
| private JavaToJavaScriptMap jjsmap; |
| private final boolean recordFileNames; |
| private final boolean recordLineNumbers; |
| private JsName stack; |
| private JsName stackDepth; |
| private JsName tmp; |
| private JDeclaredType exceptionsClass; |
| |
| private JsStackEmulator(JProgram jprogram, JsProgram jsProgram, |
| JavaToJavaScriptMap jjsmap, ConfigurationProperties config) { |
| this.jprogram = jprogram; |
| this.jsProgram = jsProgram; |
| this.jjsmap = jjsmap; |
| this.exceptionsClass = jprogram.getFromTypeMap("com.google.gwt.lang.Exceptions"); |
| |
| recordFileNames = config.getBoolean("compiler.emulatedStack.recordFileNames", false); |
| recordLineNumbers = recordFileNames || |
| config.getBoolean("compiler.emulatedStack.recordLineNumbers", false); |
| } |
| |
| private boolean shouldInstrumentFunction(JsExpression functionExpression) { |
| if (!(functionExpression instanceof HasName)) { |
| return true; |
| } |
| /** |
| * Do not instrument function in the Exceptions class (those are in involved in the |
| * exception handling machinery) nor immortal codegen types as their code is executed |
| * for setup and the stack emulation variables may have not been defined yet. |
| */ |
| JMethod method = jjsmap.nameToMethod(((HasName) functionExpression).getName()); |
| return method == null || method.getEnclosingType() != exceptionsClass |
| || jprogram.immortalCodeGenTypes.contains(method.getEnclosingType()); |
| } |
| |
| private void execImpl() { |
| wrapFunctionName = |
| JsUtils.getJsNameForMethod(jjsmap, jprogram, RuntimeConstants.EXCEPTIONS_TO_JAVA); |
| unwrapFunctionName = |
| JsUtils.getJsNameForMethod(jjsmap, jprogram, RuntimeConstants.EXCEPTIONS_TO_JS); |
| if (wrapFunctionName == null) { |
| // No exceptions caught? Weird, but possible. |
| return; |
| } |
| assert unwrapFunctionName != null; |
| initNames(); |
| makeVars(); |
| (new ReplaceUnobfuscatableNames()).accept(jsProgram); |
| (new InstrumentAllFunctions()).accept(jsProgram); |
| } |
| |
| private void initNames() { |
| stack = jsProgram.getScope().declareName("$JsStackEmulator_stack", "$stack"); |
| stackDepth = jsProgram.getScope().declareName("$JsStackEmulator_stackDepth", |
| "$stackDepth"); |
| lineNumbers = jsProgram.getScope().declareName("$JsStackEmulator_location", |
| "$location"); |
| tmp = jsProgram.getScope().declareName("$JsStackEmulator_tmp", "$tmp"); |
| } |
| |
| private void makeVars() { |
| SourceInfo info = jsProgram.createSourceInfoSynthetic(getClass()); |
| JsVar stackVar = new JsVar(info, stack); |
| stackVar.setInitExpr(new JsArrayLiteral(info)); |
| JsVar stackDepthVar = new JsVar(info, stackDepth); |
| stackDepthVar.setInitExpr(new JsNumberLiteral(info, (-1))); |
| JsVar lineNumbersVar = new JsVar(info, lineNumbers); |
| lineNumbersVar.setInitExpr(new JsArrayLiteral(info)); |
| JsVar tmpVar = new JsVar(info,tmp); |
| |
| JsVars vars; |
| JsStatement first = jsProgram.getGlobalBlock().getStatements().get(0); |
| if (first instanceof JsVars) { |
| vars = (JsVars) first; |
| } else { |
| vars = new JsVars(info); |
| jsProgram.getGlobalBlock().getStatements().add(0, vars); |
| } |
| vars.add(stackVar); |
| vars.add(stackDepthVar); |
| vars.add(lineNumbersVar); |
| vars.add(tmpVar); |
| } |
| } |
