src/jdk/nashorn/internal/codegen/ApplySpecialization.java - platform/external/jetbrains/jdk8u_nashorn - Git at Google

 /*
  * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package jdk.nashorn.internal.codegen;

 import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS_VAR;
 import static jdk.nashorn.internal.codegen.CompilerConstants.EXPLODED_ARGUMENT_PREFIX;

 import java.lang.invoke.MethodType;
 import java.net.URL;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import jdk.nashorn.internal.ir.AccessNode;
 import jdk.nashorn.internal.ir.CallNode;
 import jdk.nashorn.internal.ir.Expression;
 import jdk.nashorn.internal.ir.FunctionNode;
 import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
 import jdk.nashorn.internal.ir.IdentNode;
 import jdk.nashorn.internal.ir.LexicalContext;
 import jdk.nashorn.internal.ir.Node;
 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
 import jdk.nashorn.internal.objects.Global;
 import jdk.nashorn.internal.runtime.Context;
 import jdk.nashorn.internal.runtime.logging.DebugLogger;
 import jdk.nashorn.internal.runtime.logging.Loggable;
 import jdk.nashorn.internal.runtime.logging.Logger;
 import jdk.nashorn.internal.runtime.options.Options;

 /**
  * An optimization that attempts to turn applies into calls. This pattern
  * is very common for fake class instance creation, and apply
  * introduces expensive args collection and boxing
  *
  * <pre>
  * var Class = {
  *     create: function() {
  *         return function() { //vararg
  *             this.initialize.apply(this, arguments);
  *         }
  *     }
  * };
  *
  * Color = Class.create();
  *
  * Color.prototype = {
  *    red: 0, green: 0, blue: 0,
  *    initialize: function(r,g,b) {
  *        this.red = r;
  *        this.green = g;
  *        this.blue = b;
  *    }
  * }
  *
  * new Color(17, 47, 11);
  * </pre>
  */

 @Logger(name="apply2call")
 public final class ApplySpecialization extends NodeVisitor<LexicalContext> implements Loggable {

     private static final boolean USE_APPLY2CALL = Options.getBooleanProperty("nashorn.apply2call", true);

     private final DebugLogger log;

     private final Compiler compiler;

     private final Set<Integer> changed = new HashSet<>();

     private final Deque<List<IdentNode>> explodedArguments = new ArrayDeque<>();

     private final Deque<MethodType> callSiteTypes = new ArrayDeque<>();

     private static final String ARGUMENTS = ARGUMENTS_VAR.symbolName();

     /**
      * Apply specialization optimization. Try to explode arguments and call
      * applies as calls if they just pass on the "arguments" array and
      * "arguments" doesn't escape.
      *
      * @param compiler compiler
      */
     public ApplySpecialization(final Compiler compiler) {
         super(new LexicalContext());
         this.compiler = compiler;
         this.log = initLogger(compiler.getContext());
     }

     @Override
     public DebugLogger getLogger() {
         return log;
     }

     @Override
     public DebugLogger initLogger(final Context context) {
         return context.getLogger(this.getClass());
     }

     @SuppressWarnings("serial")
     private static class TransformFailedException extends RuntimeException {
         TransformFailedException(final FunctionNode fn, final String message) {
             super(massageURL(fn.getSource().getURL()) + '.' + fn.getName() + " => " + message, null, false, false);
         }
     }

     @SuppressWarnings("serial")
     private static class AppliesFoundException extends RuntimeException {
         AppliesFoundException() {
             super("applies_found", null, false, false);
         }
     }

     private static final AppliesFoundException HAS_APPLIES = new AppliesFoundException();

     private boolean hasApplies(final FunctionNode functionNode) {
         try {
             functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
                 @Override
                 public boolean enterFunctionNode(final FunctionNode fn) {
                     return fn == functionNode;
                 }

                 @Override
                 public boolean enterCallNode(final CallNode callNode) {
                     if (isApply(callNode)) {
                         throw HAS_APPLIES;
                     }
                     return true;
                 }
             });
         } catch (final AppliesFoundException e) {
             return true;
         }

         log.fine("There are no applies in ", DebugLogger.quote(functionNode.getName()), " - nothing to do.");
         return false; // no applies
     }

     /**
      * Arguments may only be used as args to the apply. Everything else is disqualified
      * We cannot control arguments if they escape from the method and go into an unknown
      * scope, thus we are conservative and treat any access to arguments outside the
      * apply call as a case of "we cannot apply the optimization".
      */
     private static void checkValidTransform(final FunctionNode functionNode) {

         final Set<Expression> argumentsFound = new HashSet<>();
         final Deque<Set<Expression>> stack = new ArrayDeque<>();

         //ensure that arguments is only passed as arg to apply
         functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

             private boolean isCurrentArg(final Expression expr) {
                 return !stack.isEmpty() && stack.peek().contains(expr); //args to current apply call
             }

             private boolean isArguments(final Expression expr) {
                 if (expr instanceof IdentNode && ARGUMENTS.equals(((IdentNode)expr).getName())) {
                     argumentsFound.add(expr);
                     return true;
                }
                 return false;
             }

             private boolean isParam(final String name) {
                 for (final IdentNode param : functionNode.getParameters()) {
                     if (param.getName().equals(name)) {
                         return true;
                     }
                 }
                 return false;
             }

             @Override
             public Node leaveIdentNode(final IdentNode identNode) {
                 if (isParam(identNode.getName())) {
                     throw new TransformFailedException(lc.getCurrentFunction(), "parameter: " + identNode.getName());
                 }
                 // it's OK if 'argument' occurs as the current argument of an apply
                 if (isArguments(identNode) && !isCurrentArg(identNode)) {
                     throw new TransformFailedException(lc.getCurrentFunction(), "is 'arguments': " + identNode.getName());
                 }
                 return identNode;
             }

             @Override
             public boolean enterCallNode(final CallNode callNode) {
                 final Set<Expression> callArgs = new HashSet<>();
                 if (isApply(callNode)) {
                     final List<Expression> argList = callNode.getArgs();
                     if (argList.size() != 2 || !isArguments(argList.get(argList.size() - 1))) {
                         throw new TransformFailedException(lc.getCurrentFunction(), "argument pattern not matched: " + argList);
                     }
                     callArgs.addAll(callNode.getArgs());
                 }
                 stack.push(callArgs);
                 return true;
             }

             @Override
             public Node leaveCallNode(final CallNode callNode) {
                 stack.pop();
                 return callNode;
             }
        });
     }

     @Override
     public boolean enterCallNode(final CallNode callNode) {
         return !explodedArguments.isEmpty();
     }

     @Override
     public Node leaveCallNode(final CallNode callNode) {
         //apply needs to be a global symbol or we don't allow it

         final List<IdentNode> newParams = explodedArguments.peek();
         if (isApply(callNode)) {
             final List<Expression> newArgs = new ArrayList<>();
             for (final Expression arg : callNode.getArgs()) {
                 if (arg instanceof IdentNode && ARGUMENTS.equals(((IdentNode)arg).getName())) {
                     newArgs.addAll(newParams);
                 } else {
                     newArgs.add(arg);
                 }
             }

             changed.add(lc.getCurrentFunction().getId());

             final CallNode newCallNode = callNode.setArgs(newArgs).setIsApplyToCall();

             if (log.isEnabled()) {
                 log.fine("Transformed ",
                         callNode,
                         " from apply to call => ",
                         newCallNode,
                         " in ",
                         DebugLogger.quote(lc.getCurrentFunction().getName()));
             }

             return newCallNode;
         }

         return callNode;
     }

     private void pushExplodedArgs(final FunctionNode functionNode) {
         int start = 0;

         final MethodType actualCallSiteType = compiler.getCallSiteType(functionNode);
         if (actualCallSiteType == null) {
             throw new TransformFailedException(lc.getCurrentFunction(), "No callsite type");
         }
         assert actualCallSiteType.parameterType(actualCallSiteType.parameterCount() - 1) != Object[].class : "error vararg callsite passed to apply2call " + functionNode.getName() + " " + actualCallSiteType;

         final TypeMap ptm = compiler.getTypeMap();
         if (ptm.needsCallee()) {
             start++;
         }

         start++; //we always uses this

         final List<IdentNode> params    = functionNode.getParameters();
         final List<IdentNode> newParams = new ArrayList<>();
         final long to = Math.max(params.size(), actualCallSiteType.parameterCount() - start);
         for (int i = 0; i < to; i++) {
             if (i >= params.size()) {
                 newParams.add(new IdentNode(functionNode.getToken(), functionNode.getFinish(), EXPLODED_ARGUMENT_PREFIX.symbolName() + (i)));
             } else {
                 newParams.add(params.get(i));
             }
         }

         callSiteTypes.push(actualCallSiteType);
         explodedArguments.push(newParams);
     }

     @Override
     public boolean enterFunctionNode(final FunctionNode functionNode) {
         if (!USE_APPLY2CALL) {
             return false;
         }

         if (!Global.isBuiltinFunctionPrototypeApply()) {
             log.fine("Apply transform disabled: apply/call overridden");
             assert !Global.isBuiltinFunctionPrototypeCall() : "call and apply should have the same SwitchPoint";
             return false;
         }

         if (!compiler.isOnDemandCompilation()) {
             return false;
         }

         if (functionNode.hasEval()) {
             return false;
         }

         if (!hasApplies(functionNode)) {
             return false;
         }

         if (log.isEnabled()) {
             log.info("Trying to specialize apply to call in '",
                     functionNode.getName(),
                     "' params=",
                     functionNode.getParameters(),
                     " id=",
                     functionNode.getId(),
                     " source=",
                     massageURL(functionNode.getSource().getURL()));
         }

         try {
             checkValidTransform(functionNode);
             pushExplodedArgs(functionNode);
         } catch (final TransformFailedException e) {
             log.info("Failure: ", e.getMessage());
             return false;
         }

         return true;
     }

     /**
      * Try to do the apply to call transformation
      * @return true if successful, false otherwise
      */
     @Override
     public Node leaveFunctionNode(final FunctionNode functionNode) {
         FunctionNode newFunctionNode = functionNode;
         final String functionName = newFunctionNode.getName();

         if (changed.contains(newFunctionNode.getId())) {
             newFunctionNode = newFunctionNode.clearFlag(lc, FunctionNode.USES_ARGUMENTS).
                     setFlag(lc, FunctionNode.HAS_APPLY_TO_CALL_SPECIALIZATION).
                     setParameters(lc, explodedArguments.peek());

             if (log.isEnabled()) {
                 log.info("Success: ",
                         massageURL(newFunctionNode.getSource().getURL()),
                         '.',
                         functionName,
                         "' id=",
                         newFunctionNode.getId(),
                         " params=",
                         callSiteTypes.peek());
             }
         }

         callSiteTypes.pop();
         explodedArguments.pop();

         return newFunctionNode.setState(lc, CompilationState.BUILTINS_TRANSFORMED);
     }

     private static boolean isApply(final CallNode callNode) {
         final Expression f = callNode.getFunction();
         return f instanceof AccessNode && "apply".equals(((AccessNode)f).getProperty());
     }

     private static String massageURL(final URL url) {
         if (url == null) {
             return "<null>";
         }
         final String str = url.toString();
         final int slash = str.lastIndexOf('/');
         if (slash == -1) {
             return str;
         }
         return str.substring(slash + 1);
     }
 }
	/*
	* Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package jdk.nashorn.internal.codegen;

	import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS_VAR;
	import static jdk.nashorn.internal.codegen.CompilerConstants.EXPLODED_ARGUMENT_PREFIX;

	import java.lang.invoke.MethodType;
	import java.net.URL;
	import java.util.ArrayDeque;
	import java.util.ArrayList;
	import java.util.Deque;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import jdk.nashorn.internal.ir.AccessNode;
	import jdk.nashorn.internal.ir.CallNode;
	import jdk.nashorn.internal.ir.Expression;
	import jdk.nashorn.internal.ir.FunctionNode;
	import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
	import jdk.nashorn.internal.ir.IdentNode;
	import jdk.nashorn.internal.ir.LexicalContext;
	import jdk.nashorn.internal.ir.Node;
	import jdk.nashorn.internal.ir.visitor.NodeVisitor;
	import jdk.nashorn.internal.objects.Global;
	import jdk.nashorn.internal.runtime.Context;
	import jdk.nashorn.internal.runtime.logging.DebugLogger;
	import jdk.nashorn.internal.runtime.logging.Loggable;
	import jdk.nashorn.internal.runtime.logging.Logger;
	import jdk.nashorn.internal.runtime.options.Options;

	/**
	* An optimization that attempts to turn applies into calls. This pattern
	* is very common for fake class instance creation, and apply
	* introduces expensive args collection and boxing
	*
	* <pre>
	* var Class = {
	* create: function() {
	* return function() { //vararg
	* this.initialize.apply(this, arguments);
	* }
	* }
	* };
	*
	* Color = Class.create();
	*
	* Color.prototype = {
	* red: 0, green: 0, blue: 0,
	* initialize: function(r,g,b) {
	* this.red = r;
	* this.green = g;
	* this.blue = b;
	* }
	* }
	*
	* new Color(17, 47, 11);
	* </pre>
	*/

	@Logger(name="apply2call")
	public final class ApplySpecialization extends NodeVisitor<LexicalContext> implements Loggable {

	private static final boolean USE_APPLY2CALL = Options.getBooleanProperty("nashorn.apply2call", true);

	private final DebugLogger log;

	private final Compiler compiler;

	private final Set<Integer> changed = new HashSet<>();

	private final Deque<List<IdentNode>> explodedArguments = new ArrayDeque<>();

	private final Deque<MethodType> callSiteTypes = new ArrayDeque<>();

	private static final String ARGUMENTS = ARGUMENTS_VAR.symbolName();

	/**
	* Apply specialization optimization. Try to explode arguments and call
	* applies as calls if they just pass on the "arguments" array and
	* "arguments" doesn't escape.
	*
	* @param compiler compiler
	*/
	public ApplySpecialization(final Compiler compiler) {
	super(new LexicalContext());
	this.compiler = compiler;
	this.log = initLogger(compiler.getContext());
	}

	@Override
	public DebugLogger getLogger() {
	return log;
	}

	@Override
	public DebugLogger initLogger(final Context context) {
	return context.getLogger(this.getClass());
	}

	@SuppressWarnings("serial")
	private static class TransformFailedException extends RuntimeException {
	TransformFailedException(final FunctionNode fn, final String message) {
	super(massageURL(fn.getSource().getURL()) + '.' + fn.getName() + " => " + message, null, false, false);
	}
	}

	@SuppressWarnings("serial")
	private static class AppliesFoundException extends RuntimeException {
	AppliesFoundException() {
	super("applies_found", null, false, false);
	}
	}

	private static final AppliesFoundException HAS_APPLIES = new AppliesFoundException();

	private boolean hasApplies(final FunctionNode functionNode) {
	try {
	functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
	@Override
	public boolean enterFunctionNode(final FunctionNode fn) {
	return fn == functionNode;
	}

	@Override
	public boolean enterCallNode(final CallNode callNode) {
	if (isApply(callNode)) {
	throw HAS_APPLIES;
	}
	return true;
	}
	});
	} catch (final AppliesFoundException e) {
	return true;
	}

	log.fine("There are no applies in ", DebugLogger.quote(functionNode.getName()), " - nothing to do.");
	return false; // no applies
	}

	/**
	* Arguments may only be used as args to the apply. Everything else is disqualified
	* We cannot control arguments if they escape from the method and go into an unknown
	* scope, thus we are conservative and treat any access to arguments outside the
	* apply call as a case of "we cannot apply the optimization".
	*/
	private static void checkValidTransform(final FunctionNode functionNode) {

	final Set<Expression> argumentsFound = new HashSet<>();
	final Deque<Set<Expression>> stack = new ArrayDeque<>();

	//ensure that arguments is only passed as arg to apply
	functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {

	private boolean isCurrentArg(final Expression expr) {
	return !stack.isEmpty() && stack.peek().contains(expr); //args to current apply call
	}

	private boolean isArguments(final Expression expr) {
	if (expr instanceof IdentNode && ARGUMENTS.equals(((IdentNode)expr).getName())) {
	argumentsFound.add(expr);
	return true;
	}
	return false;
	}

	private boolean isParam(final String name) {
	for (final IdentNode param : functionNode.getParameters()) {
	if (param.getName().equals(name)) {
	return true;
	}
	}
	return false;
	}

	@Override
	public Node leaveIdentNode(final IdentNode identNode) {
	if (isParam(identNode.getName())) {
	throw new TransformFailedException(lc.getCurrentFunction(), "parameter: " + identNode.getName());
	}
	// it's OK if 'argument' occurs as the current argument of an apply
	if (isArguments(identNode) && !isCurrentArg(identNode)) {
	throw new TransformFailedException(lc.getCurrentFunction(), "is 'arguments': " + identNode.getName());
	}
	return identNode;
	}

	@Override
	public boolean enterCallNode(final CallNode callNode) {
	final Set<Expression> callArgs = new HashSet<>();
	if (isApply(callNode)) {
	final List<Expression> argList = callNode.getArgs();
	if (argList.size() != 2 \|\| !isArguments(argList.get(argList.size() - 1))) {
	throw new TransformFailedException(lc.getCurrentFunction(), "argument pattern not matched: " + argList);
	}
	callArgs.addAll(callNode.getArgs());
	}
	stack.push(callArgs);
	return true;
	}

	@Override
	public Node leaveCallNode(final CallNode callNode) {
	stack.pop();
	return callNode;
	}
	});
	}

	@Override
	public boolean enterCallNode(final CallNode callNode) {
	return !explodedArguments.isEmpty();
	}

	@Override
	public Node leaveCallNode(final CallNode callNode) {
	//apply needs to be a global symbol or we don't allow it

	final List<IdentNode> newParams = explodedArguments.peek();
	if (isApply(callNode)) {
	final List<Expression> newArgs = new ArrayList<>();
	for (final Expression arg : callNode.getArgs()) {
	if (arg instanceof IdentNode && ARGUMENTS.equals(((IdentNode)arg).getName())) {
	newArgs.addAll(newParams);
	} else {
	newArgs.add(arg);
	}
	}

	changed.add(lc.getCurrentFunction().getId());

	final CallNode newCallNode = callNode.setArgs(newArgs).setIsApplyToCall();

	if (log.isEnabled()) {
	log.fine("Transformed ",
	callNode,
	" from apply to call => ",
	newCallNode,
	" in ",
	DebugLogger.quote(lc.getCurrentFunction().getName()));
	}

	return newCallNode;
	}

	return callNode;
	}

	private void pushExplodedArgs(final FunctionNode functionNode) {
	int start = 0;

	final MethodType actualCallSiteType = compiler.getCallSiteType(functionNode);
	if (actualCallSiteType == null) {
	throw new TransformFailedException(lc.getCurrentFunction(), "No callsite type");
	}
	assert actualCallSiteType.parameterType(actualCallSiteType.parameterCount() - 1) != Object[].class : "error vararg callsite passed to apply2call " + functionNode.getName() + " " + actualCallSiteType;

	final TypeMap ptm = compiler.getTypeMap();
	if (ptm.needsCallee()) {
	start++;
	}

	start++; //we always uses this

	final List<IdentNode> params = functionNode.getParameters();
	final List<IdentNode> newParams = new ArrayList<>();
	final long to = Math.max(params.size(), actualCallSiteType.parameterCount() - start);
	for (int i = 0; i < to; i++) {
	if (i >= params.size()) {
	newParams.add(new IdentNode(functionNode.getToken(), functionNode.getFinish(), EXPLODED_ARGUMENT_PREFIX.symbolName() + (i)));
	} else {
	newParams.add(params.get(i));
	}
	}

	callSiteTypes.push(actualCallSiteType);
	explodedArguments.push(newParams);
	}

	@Override
	public boolean enterFunctionNode(final FunctionNode functionNode) {
	if (!USE_APPLY2CALL) {
	return false;
	}

	if (!Global.isBuiltinFunctionPrototypeApply()) {
	log.fine("Apply transform disabled: apply/call overridden");
	assert !Global.isBuiltinFunctionPrototypeCall() : "call and apply should have the same SwitchPoint";
	return false;
	}

	if (!compiler.isOnDemandCompilation()) {
	return false;
	}

	if (functionNode.hasEval()) {
	return false;
	}

	if (!hasApplies(functionNode)) {
	return false;
	}

	if (log.isEnabled()) {
	log.info("Trying to specialize apply to call in '",
	functionNode.getName(),
	"' params=",
	functionNode.getParameters(),
	" id=",
	functionNode.getId(),
	" source=",
	massageURL(functionNode.getSource().getURL()));
	}

	try {
	checkValidTransform(functionNode);
	pushExplodedArgs(functionNode);
	} catch (final TransformFailedException e) {
	log.info("Failure: ", e.getMessage());
	return false;
	}

	return true;
	}

	/**
	* Try to do the apply to call transformation
	* @return true if successful, false otherwise
	*/
	@Override
	public Node leaveFunctionNode(final FunctionNode functionNode) {
	FunctionNode newFunctionNode = functionNode;
	final String functionName = newFunctionNode.getName();

	if (changed.contains(newFunctionNode.getId())) {
	newFunctionNode = newFunctionNode.clearFlag(lc, FunctionNode.USES_ARGUMENTS).
	setFlag(lc, FunctionNode.HAS_APPLY_TO_CALL_SPECIALIZATION).
	setParameters(lc, explodedArguments.peek());

	if (log.isEnabled()) {
	log.info("Success: ",
	massageURL(newFunctionNode.getSource().getURL()),
	'.',
	functionName,
	"' id=",
	newFunctionNode.getId(),
	" params=",
	callSiteTypes.peek());
	}
	}

	callSiteTypes.pop();
	explodedArguments.pop();

	return newFunctionNode.setState(lc, CompilationState.BUILTINS_TRANSFORMED);
	}

	private static boolean isApply(final CallNode callNode) {
	final Expression f = callNode.getFunction();
	return f instanceof AccessNode && "apply".equals(((AccessNode)f).getProperty());
	}

	private static String massageURL(final URL url) {
	if (url == null) {
	return "<null>";
	}
	final String str = url.toString();
	final int slash = str.lastIndexOf('/');
	if (slash == -1) {
	return str;
	}
	return str.substring(slash + 1);
	}
	}