dev/core/src/com/google/gwt/dev/js/JsUtils.java - gwt - Git at Google

 /*
  * Copyright 2014 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.jjs.SourceInfo;
 import com.google.gwt.dev.jjs.ast.HasJsInfo.JsMemberType;
 import com.google.gwt.dev.jjs.ast.JMethod;
 import com.google.gwt.dev.jjs.ast.JParameter;
 import com.google.gwt.dev.jjs.ast.JPrimitiveType;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.jjs.impl.JavaToJavaScriptMap;
 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.JsExprStmt;
 import com.google.gwt.dev.js.ast.JsExpression;
 import com.google.gwt.dev.js.ast.JsFunction;
 import com.google.gwt.dev.js.ast.JsInvocation;
 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.JsParameter;
 import com.google.gwt.dev.js.ast.JsReturn;
 import com.google.gwt.dev.js.ast.JsScope;
 import com.google.gwt.dev.js.ast.JsStatement;
 import com.google.gwt.dev.js.ast.JsThisRef;
 import com.google.gwt.dev.util.StringInterner;
 import com.google.gwt.thirdparty.guava.common.base.Preconditions;
 import com.google.gwt.thirdparty.guava.common.collect.Iterables;
 import com.google.gwt.thirdparty.guava.common.collect.Lists;

 import java.util.Collections;
 import java.util.List;

 import java.util.regex.Pattern;

 /**
  * Utils for JS AST.
  */
 public class JsUtils {
   /**
    * Given a JsInvocation, determine if it is invoking a JsFunction that is
    * specified to be executed only once during the program's lifetime.
    */
   public static JsFunction isExecuteOnce(JsInvocation invocation) {
     JsFunction f = isFunction(invocation.getQualifier());
     if (f != null && f.isClinit()) {
       return f;
     }
     return null;
   }

   /**
    * Given an expression, determine if it is a JsNameRef that refers to a
    * statically-defined JsFunction.
    */
   public static JsFunction isFunction(JsExpression e) {
     if (!(e instanceof JsNameRef)) {
       return null;
     }

     JsNameRef ref = (JsNameRef) e;

     // Unravel foo.call(...).
     if (!ref.getName().isObfuscatable() && CALL_STRING.equals(ref.getIdent())) {
       if (ref.getQualifier() instanceof JsNameRef) {
         ref = (JsNameRef) ref.getQualifier();
       }
     }

     JsNode staticRef = ref.getName().getStaticRef();
     if (staticRef instanceof JsFunction) {
       return (JsFunction) staticRef;
     }
     return null;
   }

   public static JsExpression createAssignment(JsExpression lhs, JsExpression rhs) {
     return createAssignment(lhs.getSourceInfo(), lhs, rhs);
   }

   public static JsExpression createAssignment(SourceInfo info, JsExpression lhs, JsExpression rhs) {
     return new JsBinaryOperation(info, JsBinaryOperator.ASG, lhs, rhs);
   }

   public static JsFunction createBridge(JMethod method, JsName polyName, JsScope scope) {
     SourceInfo sourceInfo = method.getSourceInfo();
     JsFunction bridge = new JsFunction(sourceInfo, scope);
     for (JParameter p : method.getParams()) {
       JsName name = bridge.getScope().declareName(p.getName());
       bridge.getParameters().add(new JsParameter(sourceInfo, name));
     }
     JsNameRef reference = polyName.makeQualifiedRef(sourceInfo, new JsThisRef(sourceInfo));
     List<JsExpression> args = Lists.newArrayList();
     for (JsParameter p : bridge.getParameters()) {
       args.add(p.getName().makeRef(sourceInfo));
     }

     JsExpression invocation = createInvocationOrPropertyAccess(
             InvocationStyle.NORMAL, sourceInfo, method, reference.getQualifier(), reference, args);

     JsBlock block = new JsBlock(sourceInfo);
     if (method.getType() == JPrimitiveType.VOID) {
       block.getStatements().add(invocation.makeStmt());
     } else {
       block.getStatements().add(new JsReturn(sourceInfo, invocation));
     }
     bridge.setBody(block);
     return bridge;
   }

   public static JsExpression createCommaExpression(JsExpression... expressions) {
     return createCommaExpressionHelper(expressions, 0);
   }

   private static JsExpression createCommaExpressionHelper(JsExpression[] expressions, int index) {
     int remainingExpressions = expressions.length - index;
     assert remainingExpressions >= 2;

     JsExpression lhs = expressions[index];
     JsExpression rhs = expressions[index + 1];
     if (remainingExpressions > 2) {
       rhs = createCommaExpressionHelper(expressions, index + 1);
     }

     // Construct the binary expression
     if (rhs == null) {
       return lhs;
     } else if (lhs == null) {
       return rhs;
     }
     return new JsBinaryOperation(lhs.getSourceInfo(), JsBinaryOperator.COMMA, lhs, rhs);
   }

   public static JsFunction createEmptyFunctionLiteral(SourceInfo info, JsScope scope, JsName name) {
     JsFunction func = new JsFunction(info, scope, name);
     func.setBody(new JsBlock(info));
     return func;
   }

   public static JsExpression createQualifiedNameRef(
       SourceInfo info, JsExpression base, String... names) {
     JsExpression result = base;
     for (String name : names) {
       JsNameRef nameRef = new JsNameRef(info, name);
       nameRef.setQualifier(result);
       result = nameRef;
     }
     return result;
   }

   /**
    * Given a string qualifier such as 'foo.bar.Baz', returns a chain of JsNameRef's representing
    * this qualifier.
    */
   public static JsNameRef createQualifiedNameRef(String namespace, SourceInfo sourceInfo) {
     assert !namespace.isEmpty();
     JsNameRef ref = null;
     for (String part : namespace.split("\\.")) {
       JsNameRef newRef = new JsNameRef(sourceInfo, part);
       if (ref != null) {
         newRef.setQualifier(ref);
       }
       ref = newRef;
     }
     return ref;
   }

   public static JsNameRef createQualifiedNameRef(SourceInfo info,  JsName... names) {
     JsNameRef result = null;
     for (JsName name : names) {
       if (result == null) {
         result = name.makeRef(info);
         continue;
       }
       result = name.makeQualifiedRef(info, result);
     }
     return result;
   }

   private enum TargetType {
     SETTER, GETTER, NEWINSTANCE, FUNCTION, METHOD
   }

   private enum CallStyle {
     DIRECT, USING_CALL, USING_APPLY_FOR_VARARGS_ARRAY
   }

   private static class InvocationDescriptor {
     private final TargetType targetType;
     private final CallStyle callStyle;
     private final List<JsExpression> nonVarargsArguments;
     private final JsExpression varargsArgument;
     private final JsExpression instance;
     private final JsNameRef reference;

     InvocationDescriptor(TargetType targetType, CallStyle callStyle,
         JsExpression instance, JsNameRef reference,
         List<JsExpression> nonVarargsArguments, JsExpression varargsArgument) {
       this.targetType = targetType;
       this.callStyle = callStyle;
       this.nonVarargsArguments = nonVarargsArguments;
       this.varargsArgument = varargsArgument;
       this.instance = instance;
       this.reference = reference;
     }
   }

   /**
    * Decides the type of invokation to perform, tranforming vararg calls into plain calls if
    * possible.
    */
   private static InvocationDescriptor createInvocationDescriptor(InvocationStyle invocationStyle,
       JMethod method, JsExpression instance, JsNameRef reference, List<JsExpression> args)  {

     CallStyle callStyle = invocationStyle == InvocationStyle.SUPER
         // JsFunctions that are accessed through an instance field need to be called using CALL to
         // avoid accidentally binding "this" to the field's qualifier. See bug #9328.
         || invocationStyle == InvocationStyle.FUNCTION
             && instance instanceof JsNameRef
             && ((JsNameRef) instance).getQualifier() != null
         ? CallStyle.USING_CALL : CallStyle.DIRECT;

     TargetType targetType;
     switch (invocationStyle) {
       case NEWINSTANCE:
         assert method.isConstructor();
         targetType = TargetType.NEWINSTANCE;
         break;
       case FUNCTION:
         assert method.isOrOverridesJsFunctionMethod();
         targetType = TargetType.FUNCTION;
         break;
       default:
         if (method.getJsMemberType().isPropertyAccessor()) {
           targetType = method.getJsMemberType() == JsMemberType.GETTER
               ? TargetType.GETTER : TargetType.SETTER;
         } else {
           targetType = TargetType.METHOD;
         }
         break;
     }

     JsExpression lastArgument = Iterables.getLast(args, null);
     boolean needsVarargsApply =
         method.isJsMethodVarargs() && !(lastArgument instanceof JsArrayLiteral);
     List<JsExpression> nonVarargArguments = args;
     JsExpression varargArgument = null;
     if (method.isJsMethodVarargs()) {
       nonVarargArguments = nonVarargArguments.subList(0, args.size() - 1);
       if (!needsVarargsApply) {
         nonVarargArguments.addAll(((JsArrayLiteral) lastArgument).getExpressions());
       } else {
         varargArgument = lastArgument;
         callStyle = CallStyle.USING_APPLY_FOR_VARARGS_ARRAY;
       }
     }

     instance = instance != null ? instance : JsNullLiteral.INSTANCE;
     return new InvocationDescriptor(targetType, callStyle, instance, reference,
         nonVarargArguments, varargArgument);
   }

   private static JsExpression prepareArgumentsForApply(SourceInfo sourceInfo,
       Iterable<JsExpression> nonVarargsArguments, JsExpression varargsArgument) {
     if (Iterables.isEmpty(nonVarargsArguments)) {
       return varargsArgument;
     }

     JsArrayLiteral argumentsArray = new JsArrayLiteral(sourceInfo, nonVarargsArguments);
     JsNameRef argumentsConcat = new JsNameRef(sourceInfo,"concat");
     argumentsConcat.setQualifier(argumentsArray);
     return new JsInvocation(sourceInfo, argumentsConcat, varargsArgument);
   }

   public static JsExpression createApplyInvocation(
       SourceInfo sourceInfo, InvocationDescriptor invocationDescriptor) {
     assert invocationDescriptor.callStyle == CallStyle.USING_APPLY_FOR_VARARGS_ARRAY;
     switch (invocationDescriptor.targetType) {
       case FUNCTION:
         // fn.apply(null, [p1, ..., pn].concat(varargsArray));
         return new JsInvocation(sourceInfo,
             createQualifiedNameRef(sourceInfo, invocationDescriptor.instance, "apply"),
             JsNullLiteral.INSTANCE,
             prepareArgumentsForApply(sourceInfo,
                 invocationDescriptor.nonVarargsArguments,
                 invocationDescriptor.varargsArgument));
       case METHOD:
         // Static method:
         //   q.name.apply(null, [p1, ..., pn].concat(varargsArray));
         // Instance method:
         //   instance.name.apply(instance, [p1, ..., pn].concat(varargsArray));
         // Super call:
         //   q.name.apply(instance, [p1, ..., pn].concat(varargsArray));
         JsExpression instance = invocationDescriptor.instance;
         if (instance == invocationDescriptor.reference.getQualifier()) {
           // If instance == qualifier, instance needs to be cloned as it can not appear in two
           // places in the JS AST. This needs to be done only in the case of VARRAGS_ARRAY.
           // Instance here has been normalized to be just a "leaf" JsNameRef by
           // {@link ImplementJsVarargs} so that the following translation can be avoided here.
           //   (_t = instance).name.apply(_t, [p1, ..., pn].concat(varargsArray));
           assert  (instance instanceof JsNameRef && ((JsNameRef) instance).isLeaf());
           instance = Preconditions.checkNotNull(JsSafeCloner.clone(instance));
         }

         return new JsInvocation(sourceInfo,
             createQualifiedNameRef(sourceInfo, invocationDescriptor.reference, "apply"),
             instance,
             prepareArgumentsForApply(sourceInfo,
                 invocationDescriptor.nonVarargsArguments,
                 invocationDescriptor.varargsArgument));
       case NEWINSTANCE:
         // new (q.name.bind.apply(q, [null, p1, ... pn])())()
         return new JsNew(sourceInfo, new JsInvocation(sourceInfo,
             createQualifiedNameRef(sourceInfo, invocationDescriptor.reference, "bind", "apply"),
             invocationDescriptor.reference,
             prepareArgumentsForApply(sourceInfo,
                 Iterables.concat(
                     Collections.singleton(JsNullLiteral.INSTANCE),
                     invocationDescriptor.nonVarargsArguments),
                 invocationDescriptor.varargsArgument)));
       default:
         throw new AssertionError("Target type " + invocationDescriptor.targetType
             + " invalid for varargs apply invocation");
     }
   }

   public static JsExpression createDirectInvocationOrPropertyAccess(
       SourceInfo sourceInfo, InvocationDescriptor invocationDescriptor) {
     assert invocationDescriptor.callStyle == CallStyle.DIRECT;
     switch (invocationDescriptor.targetType) {
       case SETTER:
         assert invocationDescriptor.nonVarargsArguments.size() == 1;
         return createAssignment(invocationDescriptor.reference,
             invocationDescriptor.nonVarargsArguments.get(0));
       case GETTER:
         assert invocationDescriptor.nonVarargsArguments.size() == 0;
         return invocationDescriptor.reference;
       case FUNCTION:
         return new JsInvocation(sourceInfo, invocationDescriptor.instance,
             invocationDescriptor.nonVarargsArguments);
       case METHOD:
         return new JsInvocation(sourceInfo, invocationDescriptor.reference,
             invocationDescriptor.nonVarargsArguments);
       case NEWINSTANCE:
        return new JsNew(
            sourceInfo, invocationDescriptor.reference, invocationDescriptor.nonVarargsArguments);
       default:
         throw new AssertionError("Target type " + invocationDescriptor.targetType
             + " invalid for direct invocation");
     }
   }

   public static JsExpression createCallInvocationOrSuperPropertyAccess(
       SourceInfo sourceInfo, InvocationDescriptor invocationDescriptor) {
     assert invocationDescriptor.callStyle == CallStyle.USING_CALL;
     switch (invocationDescriptor.targetType) {
       case SETTER:
         assert invocationDescriptor.nonVarargsArguments.size() == 1;
         // TODO(rluble): implement super setters.
         throw new UnsupportedOperationException("Super.setter is unsupported");
       case GETTER:
         assert invocationDescriptor.nonVarargsArguments.size() == 0;
         // TODO(rluble): implement super getters.
         throw new UnsupportedOperationException("Super.getter is unsupported");
       case FUNCTION:
         // instance.call(null, p1, ..., pn)
         return createCallInvocation(sourceInfo, invocationDescriptor.instance,
             JsNullLiteral.INSTANCE, invocationDescriptor.nonVarargsArguments);
       case METHOD:
         // q.methodname.call(instance, p1, ..., pn)
         return createCallInvocation(sourceInfo, invocationDescriptor.reference,
             invocationDescriptor.instance, invocationDescriptor.nonVarargsArguments);
       default:
         throw new AssertionError("Target type " + invocationDescriptor.targetType
             + " invalid for super invocation");
     }
   }

   /**
    * Synthesize an invocation using .call().
    */
   private static JsInvocation createCallInvocation(SourceInfo sourceInfo, JsExpression target,
       JsExpression instance, Iterable<JsExpression> arguments) {
     return new JsInvocation(sourceInfo, createQualifiedNameRef(sourceInfo, target, "call"),
         Iterables.concat(Collections.singleton(instance),arguments));
   }

   /**
    * Invocation styles.
    */
   public enum InvocationStyle {
     NORMAL, FUNCTION, SUPER, NEWINSTANCE
   }

   public static JsExpression createInvocationOrPropertyAccess(InvocationStyle invocationStyle,
       SourceInfo sourceInfo, JMethod method, JsExpression instance, JsNameRef reference,
       List<JsExpression> args) {
     InvocationDescriptor invocationDescriptor =
         createInvocationDescriptor(invocationStyle, method, instance, reference, args);
     switch (invocationDescriptor.callStyle) {
       case DIRECT:
         return createDirectInvocationOrPropertyAccess(sourceInfo, invocationDescriptor);
       case USING_CALL:
         return createCallInvocationOrSuperPropertyAccess(sourceInfo, invocationDescriptor);
       case USING_APPLY_FOR_VARARGS_ARRAY:
         return createApplyInvocation(sourceInfo, invocationDescriptor);
     }
     throw new AssertionError();
   }

   /**
    * Attempts to extract a single expression from a given statement and returns
    * it. If no such expression exists, returns <code>null</code>.
    */
   public static JsExpression extractExpression(JsStatement stmt) {
     if (stmt == null) {
       return null;
     }

     if (stmt instanceof JsExprStmt) {
       return ((JsExprStmt) stmt).getExpression();
     }

     if (stmt instanceof JsBlock && ((JsBlock) stmt).getStatements().size() == 1) {
       return extractExpression(((JsBlock) stmt).getStatements().get(0));
     }

     return null;
   }

   public static JsName getJsNameForMethod(JavaToJavaScriptMap jjsmap, JProgram jprogram,
       String indexedMethodName) {
     return jjsmap.nameForMethod(jprogram.getIndexedMethod(indexedMethodName));
   }

   public static JsName getJsNameForField(JavaToJavaScriptMap jjsmap, JProgram jprogram,
       String indexedMethodName) {
     return jjsmap.nameForField(jprogram.getIndexedField(indexedMethodName));
   }

   public static boolean isEmpty(JsStatement stmt) {
     if (stmt == null) {
       return true;
     }
     return (stmt instanceof JsBlock && ((JsBlock) stmt).getStatements().isEmpty());
   }

   /**
    * If the statement is a JsExprStmt that declares a function with no other
    * side effects, returns that function; otherwise <code>null</code>.
    */
   public static JsFunction isFunctionDeclaration(JsStatement stmt) {
     if (stmt instanceof JsExprStmt) {
       JsExprStmt exprStmt = (JsExprStmt) stmt;
       JsExpression expr = exprStmt.getExpression();
       if (expr instanceof JsFunction) {
         JsFunction func = (JsFunction) expr;
         if (func.getName() != null) {
           return func;
         }
       }
     }
     return null;
   }

   /**
    * A JavaScript identifier contains only letters, numbers, _, $ and does not begin with a number.
    * There are actually other valid identifiers, such as ones that contain escaped Unicode
    * characters but we disallow those for the time being.
    */
   public static boolean isValidJsIdentifier(String name) {
     return JAVASCRIPT_VALID_IDENTIFIER_PATTERN.matcher(name).matches();
   }

   public static boolean isValidJsQualifiedName(String name) {
     return JAVASCRIPT_VALID_QUALIFIED_NAME_PATTERN.matcher(name).matches();
   }

   private static final String VALID_JS_NAME_REGEX = "[a-zA-Z_$][\\w_$]*";
   private static final Pattern JAVASCRIPT_VALID_QUALIFIED_NAME_PATTERN =
       Pattern.compile(VALID_JS_NAME_REGEX + "(\\." + VALID_JS_NAME_REGEX + ")*");
   private static final Pattern JAVASCRIPT_VALID_IDENTIFIER_PATTERN =
       Pattern.compile(VALID_JS_NAME_REGEX);
   private static final String CALL_STRING = StringInterner.get().intern("call");

   private JsUtils() {
   }
 }
	/*
	* Copyright 2014 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.jjs.SourceInfo;
	import com.google.gwt.dev.jjs.ast.HasJsInfo.JsMemberType;
	import com.google.gwt.dev.jjs.ast.JMethod;
	import com.google.gwt.dev.jjs.ast.JParameter;
	import com.google.gwt.dev.jjs.ast.JPrimitiveType;
	import com.google.gwt.dev.jjs.ast.JProgram;
	import com.google.gwt.dev.jjs.impl.JavaToJavaScriptMap;
	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.JsExprStmt;
	import com.google.gwt.dev.js.ast.JsExpression;
	import com.google.gwt.dev.js.ast.JsFunction;
	import com.google.gwt.dev.js.ast.JsInvocation;
	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.JsParameter;
	import com.google.gwt.dev.js.ast.JsReturn;
	import com.google.gwt.dev.js.ast.JsScope;
	import com.google.gwt.dev.js.ast.JsStatement;
	import com.google.gwt.dev.js.ast.JsThisRef;
	import com.google.gwt.dev.util.StringInterner;
	import com.google.gwt.thirdparty.guava.common.base.Preconditions;
	import com.google.gwt.thirdparty.guava.common.collect.Iterables;
	import com.google.gwt.thirdparty.guava.common.collect.Lists;

	import java.util.Collections;
	import java.util.List;

	import java.util.regex.Pattern;

	/**
	* Utils for JS AST.
	*/
	public class JsUtils {
	/**
	* Given a JsInvocation, determine if it is invoking a JsFunction that is
	* specified to be executed only once during the program's lifetime.
	*/
	public static JsFunction isExecuteOnce(JsInvocation invocation) {
	JsFunction f = isFunction(invocation.getQualifier());
	if (f != null && f.isClinit()) {
	return f;
	}
	return null;
	}

	/**
	* Given an expression, determine if it is a JsNameRef that refers to a
	* statically-defined JsFunction.
	*/
	public static JsFunction isFunction(JsExpression e) {
	if (!(e instanceof JsNameRef)) {
	return null;
	}

	JsNameRef ref = (JsNameRef) e;

	// Unravel foo.call(...).
	if (!ref.getName().isObfuscatable() && CALL_STRING.equals(ref.getIdent())) {
	if (ref.getQualifier() instanceof JsNameRef) {
	ref = (JsNameRef) ref.getQualifier();
	}
	}

	JsNode staticRef = ref.getName().getStaticRef();
	if (staticRef instanceof JsFunction) {
	return (JsFunction) staticRef;
	}
	return null;
	}

	public static JsExpression createAssignment(JsExpression lhs, JsExpression rhs) {
	return createAssignment(lhs.getSourceInfo(), lhs, rhs);
	}

	public static JsExpression createAssignment(SourceInfo info, JsExpression lhs, JsExpression rhs) {
	return new JsBinaryOperation(info, JsBinaryOperator.ASG, lhs, rhs);
	}

	public static JsFunction createBridge(JMethod method, JsName polyName, JsScope scope) {
	SourceInfo sourceInfo = method.getSourceInfo();
	JsFunction bridge = new JsFunction(sourceInfo, scope);
	for (JParameter p : method.getParams()) {
	JsName name = bridge.getScope().declareName(p.getName());
	bridge.getParameters().add(new JsParameter(sourceInfo, name));
	}
	JsNameRef reference = polyName.makeQualifiedRef(sourceInfo, new JsThisRef(sourceInfo));
	List<JsExpression> args = Lists.newArrayList();
	for (JsParameter p : bridge.getParameters()) {
	args.add(p.getName().makeRef(sourceInfo));
	}

	JsExpression invocation = createInvocationOrPropertyAccess(
	InvocationStyle.NORMAL, sourceInfo, method, reference.getQualifier(), reference, args);

	JsBlock block = new JsBlock(sourceInfo);
	if (method.getType() == JPrimitiveType.VOID) {
	block.getStatements().add(invocation.makeStmt());
	} else {
	block.getStatements().add(new JsReturn(sourceInfo, invocation));
	}
	bridge.setBody(block);
	return bridge;
	}

	public static JsExpression createCommaExpression(JsExpression... expressions) {
	return createCommaExpressionHelper(expressions, 0);
	}

	private static JsExpression createCommaExpressionHelper(JsExpression[] expressions, int index) {
	int remainingExpressions = expressions.length - index;
	assert remainingExpressions >= 2;

	JsExpression lhs = expressions[index];
	JsExpression rhs = expressions[index + 1];
	if (remainingExpressions > 2) {
	rhs = createCommaExpressionHelper(expressions, index + 1);
	}

	// Construct the binary expression
	if (rhs == null) {
	return lhs;
	} else if (lhs == null) {
	return rhs;
	}
	return new JsBinaryOperation(lhs.getSourceInfo(), JsBinaryOperator.COMMA, lhs, rhs);
	}

	public static JsFunction createEmptyFunctionLiteral(SourceInfo info, JsScope scope, JsName name) {
	JsFunction func = new JsFunction(info, scope, name);
	func.setBody(new JsBlock(info));
	return func;
	}

	public static JsExpression createQualifiedNameRef(
	SourceInfo info, JsExpression base, String... names) {
	JsExpression result = base;
	for (String name : names) {
	JsNameRef nameRef = new JsNameRef(info, name);
	nameRef.setQualifier(result);
	result = nameRef;
	}
	return result;
	}

	/**
	* Given a string qualifier such as 'foo.bar.Baz', returns a chain of JsNameRef's representing
	* this qualifier.
	*/
	public static JsNameRef createQualifiedNameRef(String namespace, SourceInfo sourceInfo) {
	assert !namespace.isEmpty();
	JsNameRef ref = null;
	for (String part : namespace.split("\\.")) {
	JsNameRef newRef = new JsNameRef(sourceInfo, part);
	if (ref != null) {
	newRef.setQualifier(ref);
	}
	ref = newRef;
	}
	return ref;
	}

	public static JsNameRef createQualifiedNameRef(SourceInfo info, JsName... names) {
	JsNameRef result = null;
	for (JsName name : names) {
	if (result == null) {
	result = name.makeRef(info);
	continue;
	}
	result = name.makeQualifiedRef(info, result);
	}
	return result;
	}

	private enum TargetType {
	SETTER, GETTER, NEWINSTANCE, FUNCTION, METHOD
	}

	private enum CallStyle {
	DIRECT, USING_CALL, USING_APPLY_FOR_VARARGS_ARRAY
	}

	private static class InvocationDescriptor {
	private final TargetType targetType;
	private final CallStyle callStyle;
	private final List<JsExpression> nonVarargsArguments;
	private final JsExpression varargsArgument;
	private final JsExpression instance;
	private final JsNameRef reference;

	InvocationDescriptor(TargetType targetType, CallStyle callStyle,
	JsExpression instance, JsNameRef reference,
	List<JsExpression> nonVarargsArguments, JsExpression varargsArgument) {
	this.targetType = targetType;
	this.callStyle = callStyle;
	this.nonVarargsArguments = nonVarargsArguments;
	this.varargsArgument = varargsArgument;
	this.instance = instance;
	this.reference = reference;
	}
	}

	/**
	* Decides the type of invokation to perform, tranforming vararg calls into plain calls if
	* possible.
	*/
	private static InvocationDescriptor createInvocationDescriptor(InvocationStyle invocationStyle,
	JMethod method, JsExpression instance, JsNameRef reference, List<JsExpression> args) {

	CallStyle callStyle = invocationStyle == InvocationStyle.SUPER
	// JsFunctions that are accessed through an instance field need to be called using CALL to
	// avoid accidentally binding "this" to the field's qualifier. See bug #9328.
	\|\| invocationStyle == InvocationStyle.FUNCTION
	&& instance instanceof JsNameRef
	&& ((JsNameRef) instance).getQualifier() != null
	? CallStyle.USING_CALL : CallStyle.DIRECT;

	TargetType targetType;
	switch (invocationStyle) {
	case NEWINSTANCE:
	assert method.isConstructor();
	targetType = TargetType.NEWINSTANCE;
	break;
	case FUNCTION:
	assert method.isOrOverridesJsFunctionMethod();
	targetType = TargetType.FUNCTION;
	break;
	default:
	if (method.getJsMemberType().isPropertyAccessor()) {
	targetType = method.getJsMemberType() == JsMemberType.GETTER
	? TargetType.GETTER : TargetType.SETTER;
	} else {
	targetType = TargetType.METHOD;
	}
	break;
	}

	JsExpression lastArgument = Iterables.getLast(args, null);
	boolean needsVarargsApply =
	method.isJsMethodVarargs() && !(lastArgument instanceof JsArrayLiteral);
	List<JsExpression> nonVarargArguments = args;
	JsExpression varargArgument = null;
	if (method.isJsMethodVarargs()) {
	nonVarargArguments = nonVarargArguments.subList(0, args.size() - 1);
	if (!needsVarargsApply) {
	nonVarargArguments.addAll(((JsArrayLiteral) lastArgument).getExpressions());
	} else {
	varargArgument = lastArgument;
	callStyle = CallStyle.USING_APPLY_FOR_VARARGS_ARRAY;
	}
	}

	instance = instance != null ? instance : JsNullLiteral.INSTANCE;
	return new InvocationDescriptor(targetType, callStyle, instance, reference,
	nonVarargArguments, varargArgument);
	}

	private static JsExpression prepareArgumentsForApply(SourceInfo sourceInfo,
	Iterable<JsExpression> nonVarargsArguments, JsExpression varargsArgument) {
	if (Iterables.isEmpty(nonVarargsArguments)) {
	return varargsArgument;
	}

	JsArrayLiteral argumentsArray = new JsArrayLiteral(sourceInfo, nonVarargsArguments);
	JsNameRef argumentsConcat = new JsNameRef(sourceInfo,"concat");
	argumentsConcat.setQualifier(argumentsArray);
	return new JsInvocation(sourceInfo, argumentsConcat, varargsArgument);
	}

	public static JsExpression createApplyInvocation(
	SourceInfo sourceInfo, InvocationDescriptor invocationDescriptor) {
	assert invocationDescriptor.callStyle == CallStyle.USING_APPLY_FOR_VARARGS_ARRAY;
	switch (invocationDescriptor.targetType) {
	case FUNCTION:
	// fn.apply(null, [p1, ..., pn].concat(varargsArray));
	return new JsInvocation(sourceInfo,
	createQualifiedNameRef(sourceInfo, invocationDescriptor.instance, "apply"),
	JsNullLiteral.INSTANCE,
	prepareArgumentsForApply(sourceInfo,
	invocationDescriptor.nonVarargsArguments,
	invocationDescriptor.varargsArgument));
	case METHOD:
	// Static method:
	// q.name.apply(null, [p1, ..., pn].concat(varargsArray));
	// Instance method:
	// instance.name.apply(instance, [p1, ..., pn].concat(varargsArray));
	// Super call:
	// q.name.apply(instance, [p1, ..., pn].concat(varargsArray));
	JsExpression instance = invocationDescriptor.instance;
	if (instance == invocationDescriptor.reference.getQualifier()) {
	// If instance == qualifier, instance needs to be cloned as it can not appear in two
	// places in the JS AST. This needs to be done only in the case of VARRAGS_ARRAY.
	// Instance here has been normalized to be just a "leaf" JsNameRef by
	// {@link ImplementJsVarargs} so that the following translation can be avoided here.
	// (_t = instance).name.apply(_t, [p1, ..., pn].concat(varargsArray));
	assert (instance instanceof JsNameRef && ((JsNameRef) instance).isLeaf());
	instance = Preconditions.checkNotNull(JsSafeCloner.clone(instance));
	}

	return new JsInvocation(sourceInfo,
	createQualifiedNameRef(sourceInfo, invocationDescriptor.reference, "apply"),
	instance,
	prepareArgumentsForApply(sourceInfo,
	invocationDescriptor.nonVarargsArguments,
	invocationDescriptor.varargsArgument));
	case NEWINSTANCE:
	// new (q.name.bind.apply(q, [null, p1, ... pn])())()
	return new JsNew(sourceInfo, new JsInvocation(sourceInfo,
	createQualifiedNameRef(sourceInfo, invocationDescriptor.reference, "bind", "apply"),
	invocationDescriptor.reference,
	prepareArgumentsForApply(sourceInfo,
	Iterables.concat(
	Collections.singleton(JsNullLiteral.INSTANCE),
	invocationDescriptor.nonVarargsArguments),
	invocationDescriptor.varargsArgument)));
	default:
	throw new AssertionError("Target type " + invocationDescriptor.targetType
	+ " invalid for varargs apply invocation");
	}
	}

	public static JsExpression createDirectInvocationOrPropertyAccess(
	SourceInfo sourceInfo, InvocationDescriptor invocationDescriptor) {
	assert invocationDescriptor.callStyle == CallStyle.DIRECT;
	switch (invocationDescriptor.targetType) {
	case SETTER:
	assert invocationDescriptor.nonVarargsArguments.size() == 1;
	return createAssignment(invocationDescriptor.reference,
	invocationDescriptor.nonVarargsArguments.get(0));
	case GETTER:
	assert invocationDescriptor.nonVarargsArguments.size() == 0;
	return invocationDescriptor.reference;
	case FUNCTION:
	return new JsInvocation(sourceInfo, invocationDescriptor.instance,
	invocationDescriptor.nonVarargsArguments);
	case METHOD:
	return new JsInvocation(sourceInfo, invocationDescriptor.reference,
	invocationDescriptor.nonVarargsArguments);
	case NEWINSTANCE:
	return new JsNew(
	sourceInfo, invocationDescriptor.reference, invocationDescriptor.nonVarargsArguments);
	default:
	throw new AssertionError("Target type " + invocationDescriptor.targetType
	+ " invalid for direct invocation");
	}
	}

	public static JsExpression createCallInvocationOrSuperPropertyAccess(
	SourceInfo sourceInfo, InvocationDescriptor invocationDescriptor) {
	assert invocationDescriptor.callStyle == CallStyle.USING_CALL;
	switch (invocationDescriptor.targetType) {
	case SETTER:
	assert invocationDescriptor.nonVarargsArguments.size() == 1;
	// TODO(rluble): implement super setters.
	throw new UnsupportedOperationException("Super.setter is unsupported");
	case GETTER:
	assert invocationDescriptor.nonVarargsArguments.size() == 0;
	// TODO(rluble): implement super getters.
	throw new UnsupportedOperationException("Super.getter is unsupported");
	case FUNCTION:
	// instance.call(null, p1, ..., pn)
	return createCallInvocation(sourceInfo, invocationDescriptor.instance,
	JsNullLiteral.INSTANCE, invocationDescriptor.nonVarargsArguments);
	case METHOD:
	// q.methodname.call(instance, p1, ..., pn)
	return createCallInvocation(sourceInfo, invocationDescriptor.reference,
	invocationDescriptor.instance, invocationDescriptor.nonVarargsArguments);
	default:
	throw new AssertionError("Target type " + invocationDescriptor.targetType
	+ " invalid for super invocation");
	}
	}

	/**
	* Synthesize an invocation using .call().
	*/
	private static JsInvocation createCallInvocation(SourceInfo sourceInfo, JsExpression target,
	JsExpression instance, Iterable<JsExpression> arguments) {
	return new JsInvocation(sourceInfo, createQualifiedNameRef(sourceInfo, target, "call"),
	Iterables.concat(Collections.singleton(instance),arguments));
	}

	/**
	* Invocation styles.
	*/
	public enum InvocationStyle {
	NORMAL, FUNCTION, SUPER, NEWINSTANCE
	}

	public static JsExpression createInvocationOrPropertyAccess(InvocationStyle invocationStyle,
	SourceInfo sourceInfo, JMethod method, JsExpression instance, JsNameRef reference,
	List<JsExpression> args) {
	InvocationDescriptor invocationDescriptor =
	createInvocationDescriptor(invocationStyle, method, instance, reference, args);
	switch (invocationDescriptor.callStyle) {
	case DIRECT:
	return createDirectInvocationOrPropertyAccess(sourceInfo, invocationDescriptor);
	case USING_CALL:
	return createCallInvocationOrSuperPropertyAccess(sourceInfo, invocationDescriptor);
	case USING_APPLY_FOR_VARARGS_ARRAY:
	return createApplyInvocation(sourceInfo, invocationDescriptor);
	}
	throw new AssertionError();
	}

	/**
	* Attempts to extract a single expression from a given statement and returns
	* it. If no such expression exists, returns <code>null</code>.
	*/
	public static JsExpression extractExpression(JsStatement stmt) {
	if (stmt == null) {
	return null;
	}

	if (stmt instanceof JsExprStmt) {
	return ((JsExprStmt) stmt).getExpression();
	}

	if (stmt instanceof JsBlock && ((JsBlock) stmt).getStatements().size() == 1) {
	return extractExpression(((JsBlock) stmt).getStatements().get(0));
	}

	return null;
	}

	public static JsName getJsNameForMethod(JavaToJavaScriptMap jjsmap, JProgram jprogram,
	String indexedMethodName) {
	return jjsmap.nameForMethod(jprogram.getIndexedMethod(indexedMethodName));
	}

	public static JsName getJsNameForField(JavaToJavaScriptMap jjsmap, JProgram jprogram,
	String indexedMethodName) {
	return jjsmap.nameForField(jprogram.getIndexedField(indexedMethodName));
	}

	public static boolean isEmpty(JsStatement stmt) {
	if (stmt == null) {
	return true;
	}
	return (stmt instanceof JsBlock && ((JsBlock) stmt).getStatements().isEmpty());
	}

	/**
	* If the statement is a JsExprStmt that declares a function with no other
	* side effects, returns that function; otherwise <code>null</code>.
	*/
	public static JsFunction isFunctionDeclaration(JsStatement stmt) {
	if (stmt instanceof JsExprStmt) {
	JsExprStmt exprStmt = (JsExprStmt) stmt;
	JsExpression expr = exprStmt.getExpression();
	if (expr instanceof JsFunction) {
	JsFunction func = (JsFunction) expr;
	if (func.getName() != null) {
	return func;
	}
	}
	}
	return null;
	}

	/**
	* A JavaScript identifier contains only letters, numbers, _, $ and does not begin with a number.
	* There are actually other valid identifiers, such as ones that contain escaped Unicode
	* characters but we disallow those for the time being.
	*/
	public static boolean isValidJsIdentifier(String name) {
	return JAVASCRIPT_VALID_IDENTIFIER_PATTERN.matcher(name).matches();
	}

	public static boolean isValidJsQualifiedName(String name) {
	return JAVASCRIPT_VALID_QUALIFIED_NAME_PATTERN.matcher(name).matches();
	}

	private static final String VALID_JS_NAME_REGEX = "[a-zA-Z_$][\\w_$]*";
	private static final Pattern JAVASCRIPT_VALID_QUALIFIED_NAME_PATTERN =
	Pattern.compile(VALID_JS_NAME_REGEX + "(\\." + VALID_JS_NAME_REGEX + ")*");
	private static final Pattern JAVASCRIPT_VALID_IDENTIFIER_PATTERN =
	Pattern.compile(VALID_JS_NAME_REGEX);
	private static final String CALL_STRING = StringInterner.get().intern("call");

	private JsUtils() {
	}
	}