dev/core/src/com/google/gwt/dev/jjs/impl/ImplementCastsAndTypeChecks.java - gwt - Git at Google

 /*
  * Copyright 2008 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.jjs.impl;

 import com.google.gwt.dev.jjs.SourceInfo;
 import com.google.gwt.dev.jjs.ast.Context;
 import com.google.gwt.dev.jjs.ast.JArrayType;
 import com.google.gwt.dev.jjs.ast.JBinaryOperation;
 import com.google.gwt.dev.jjs.ast.JBinaryOperator;
 import com.google.gwt.dev.jjs.ast.JCastOperation;
 import com.google.gwt.dev.jjs.ast.JDeclaredType;
 import com.google.gwt.dev.jjs.ast.JExpression;
 import com.google.gwt.dev.jjs.ast.JInstanceOf;
 import com.google.gwt.dev.jjs.ast.JInterfaceType;
 import com.google.gwt.dev.jjs.ast.JMethod;
 import com.google.gwt.dev.jjs.ast.JMethodCall;
 import com.google.gwt.dev.jjs.ast.JModVisitor;
 import com.google.gwt.dev.jjs.ast.JPrimitiveType;
 import com.google.gwt.dev.jjs.ast.JProgram;
 import com.google.gwt.dev.jjs.ast.JReferenceType;
 import com.google.gwt.dev.jjs.ast.JRuntimeTypeReference;
 import com.google.gwt.dev.jjs.ast.JType;
 import com.google.gwt.dev.jjs.ast.RuntimeConstants;
 import com.google.gwt.dev.jjs.ast.js.JsniMethodRef;
 import com.google.gwt.thirdparty.guava.common.collect.Maps;

 import java.util.Map;

 /**
  * Replace cast and instanceof operations with calls to the Cast class. Depends
  * on {@link CatchBlockNormalizer}, {@link CompoundAssignmentNormalizer},
  * {@link Devirtualizer}, and {@link LongCastNormalizer} having already run.
  * <p>
  * May or may not prune trivial casts depending on configuration.
  */
 public class ImplementCastsAndTypeChecks {

   /**
    * Replaces all casts and instanceof operations with calls to implementation
    * methods.
    */
   private class ReplaceTypeChecksVisitor extends JModVisitor {

     @Override
     public void endVisit(JCastOperation x, Context ctx) {
       JType toType = x.getCastType();
       JExpression expr = x.getExpr();

       SourceInfo info = x.getSourceInfo();
       if (pruneTrivialCasts && toType.isNullType()) {
         /**
          * A null type cast is used as a placeholder value to indicate that the
          * user tried a cast that couldn't possibly work. Typically this means
          * either the statically resolvable arg type is incompatible with the
          * target type, or the target type was globally uninstantiable.
          *
          * See {@link TypeTightener.TightenTypesVisitor#endVisit(JCastOperation, Context)}
          *
          * We handle this cast by throwing a ClassCastException, unless the
          * argument is null.
          */
         JMethod method = program.getIndexedMethod(
             RuntimeConstants.CAST_THROW_CLASS_CAST_EXCEPTION_UNLESS_NULL);
         // Note, we must update the method call to return the null type.
         JMethodCall call = new JMethodCall(info, null, method, expr);
         call.overrideReturnType(toType);
         ctx.replaceMe(call);
         return;
       }

       if (toType instanceof JReferenceType) {
         JExpression curExpr = expr;
         JReferenceType refType = (JReferenceType) toType.getUnderlyingType();
         JReferenceType argType = (JReferenceType) expr.getType();

         if (refType instanceof JArrayType) {
           // Arrays of any subclass of JavaScriptObject are considered arrays of JavaScriptObject
           // for casting and instanceof purposes.
           refType =  (JReferenceType) program.normalizeJsoType(refType);
         }

         if (pruneTrivialCasts && program.typeOracle.castSucceedsTrivially(argType, refType) ||
             determineTypeCategoryForType(refType) == TypeCategory.TYPE_JAVA_LANG_OBJECT) {
           // just remove the cast
           ctx.replaceMe(curExpr);
           return;
         } else if (program.typeOracle.isEffectivelyJavaScriptObject(argType)
             && program.typeOracle.isEffectivelyJavaScriptObject(refType)) {
           // leave the cast instance for Pruner/CFA, remove in GenJSAST
           return;
         }
         // A cast is still needed.  Substitute the appropriate Cast implementation.
         ctx.replaceMe(implementCastOrInstanceOfOperation(x.getSourceInfo(), curExpr, refType,
             dynamicCastMethodsByTargetTypeCategory, true));
         return;
       }

       // It is a primitive type, perform the necessary coercion.

       assert toType.isPrimitiveType();
       /*
        * See JLS 5.1.3: if a cast narrows from one type to another, we must
        * call a narrowing conversion function. EXCEPTION: we currently have no
        * way to narrow double to float, so don't bother.
        */
       JPrimitiveType tByte = program.getTypePrimitiveByte();
       JPrimitiveType tChar = program.getTypePrimitiveChar();
       JPrimitiveType tShort = program.getTypePrimitiveShort();
       JPrimitiveType tInt = program.getTypePrimitiveInt();
       JPrimitiveType tLong = program.getTypePrimitiveLong();
       JPrimitiveType tFloat = program.getTypePrimitiveFloat();
       JPrimitiveType tDouble = program.getTypePrimitiveDouble();
       JType fromType = expr.getType();

       String methodName = null;

       if (tLong == fromType && tLong != toType) {
         if (tByte == toType || tShort == toType || tChar == toType) {
           /*
            * We need a double call here, one to convert long->int, and another
            * one to narrow. Construct the inner call here and fall through to
            * do the narrowing conversion.
            */
           JMethod castMethod = program.getIndexedMethod(RuntimeConstants.LONG_LIB_TO_INT);
           JMethodCall call = new JMethodCall(info, null, castMethod);
           call.addArg(expr);
           expr = call;
           fromType = tInt;
         } else if (tInt == toType) {
           methodName = RuntimeConstants.LONG_LIB_TO_INT;
         } else if (tFloat == toType || tDouble == toType) {
           methodName = RuntimeConstants.LONG_LIB_TO_DOUBLE;
         }
       }

       if (toType == tLong && fromType != tLong) {
         // Longs get special treatment.
         if (tByte == fromType || tShort == fromType || tChar == fromType || tInt == fromType) {
           methodName = RuntimeConstants.LONG_LIB_FROM_INT;
         } else if (tFloat == fromType || tDouble == fromType) {
           methodName = RuntimeConstants.LONG_LIB_FROM_DOUBLE;
         }
       } else if (tByte == fromType) {
         if (tChar == toType) {
           methodName = "Cast.narrow_" + toType.getName();
         }
       } else if (tShort == fromType) {
         if (tByte == toType || tChar == toType) {
           methodName = "Cast.narrow_" + toType.getName();
         }
       } else if (tChar == fromType) {
         if (tByte == toType || tShort == toType) {
           methodName = "Cast.narrow_" + toType.getName();
         }
       } else if (tInt == fromType) {
         if (tByte == toType || tShort == toType || tChar == toType) {
           methodName = "Cast.narrow_" + toType.getName();
         }
       } else if (tFloat == fromType || tDouble == fromType) {
         if (tByte == toType || tShort == toType || tChar == toType || tInt == toType) {
           methodName = "Cast.round_" + toType.getName();
         }
       }

       if (methodName != null) {
         JMethod castMethod = program.getIndexedMethod(methodName);
         JMethodCall call = new JMethodCall(info, null, castMethod, expr);
         call.overrideReturnType(toType);
         ctx.replaceMe(call);
       } else {
         // Just remove the cast
         ctx.replaceMe(expr);
       }
     }

     @Override
     public void endVisit(JInstanceOf x, Context ctx) {
       JReferenceType argType = (JReferenceType) x.getExpr().getType();
       JReferenceType toType = x.getTestType();
       // Only tests on run-time types are supported
       assert (toType == toType.getUnderlyingType());

       if (toType instanceof JArrayType) {
         // Arrays of any subclass of JavaScriptObject are considered arrays of JavaScriptObject
         // for casting and instanceof purposes.
         toType =  (JReferenceType) program.normalizeJsoType(toType);
       }

       assert !toType.isJsNative() || !(toType instanceof JInterfaceType);

       boolean isTrivialCast = program.typeOracle.castSucceedsTrivially(argType, toType)
           // don't depend on type-tightener having run
           || (program.typeOracle.isEffectivelyJavaScriptObject(argType)
               && program.typeOracle.isEffectivelyJavaScriptObject(toType));
       if (pruneTrivialCasts && isTrivialCast ||
           determineTypeCategoryForType(toType) == TypeCategory.TYPE_JAVA_LANG_OBJECT) {
         // trivially true if non-null; replace with a null test
         JBinaryOperation eq =
             new JBinaryOperation(x.getSourceInfo(), program.getTypePrimitiveBoolean(),
                 JBinaryOperator.NEQ, x.getExpr(), program.getLiteralNull());
         ctx.replaceMe(eq);
       } else {
         // Replace the instance of check by a call to the appropriate instanceof method in class
         // Cast.
         ctx.replaceMe(implementCastOrInstanceOfOperation(x.getSourceInfo(), x.getExpr(), toType,
             instanceOfMethodsByTargetTypeCategory, false));
       }
     }
   }

   /**
    * Determines the type category for a specific reference type.
    */
   private TypeCategory determineTypeCategoryForType(JReferenceType type) {
     TypeCategory typeCategory = TypeCategory.typeCategoryForType(type, program);

     assert typeCategory.castInstanceOfQualifier() != null;

     return typeCategory;
   }

   /**
    * Returns an expression implementing the instanceof/dynamicCast operations.
    */
   private JMethodCall implementCastOrInstanceOfOperation(SourceInfo sourceInfo,
       JExpression targetExpression, JReferenceType targetType,
       Map<TypeCategory, JMethod> targetMethodByTypeCategory, boolean overrideReturnType) {

     TypeCategory targetTypeCategory = determineTypeCategoryForType(targetType);
     JMethod method = targetMethodByTypeCategory.get(targetTypeCategory);
     assert method != null;
     JMethodCall call = new JMethodCall(sourceInfo, null, method);
     if (overrideReturnType) {
       // Create a method call overriding the return type so that operations like Cast.dynamicCast
       // don't change the type of the original method call expression.
       call.overrideReturnType(targetType);
     }

     call.addArg(targetExpression);

     if (method.getParams().size() < 2) {
       // The cast checking method does not require an additional parameter. This situation arises
       // when the call is a cast check and cast checking has been disabled or when the type category
       // provides enough information, e.g. TYPE_UNTYPED_ARRAY.
       return call;
     } else if (targetTypeCategory.requiresTypeId()) {
       call.addArg((new JRuntimeTypeReference(sourceInfo, program.getTypeJavaLangObject(),
           targetType)));
       return call;
     } else if (targetTypeCategory.requiresJsConstructor()) {
       JDeclaredType declaredType = (JDeclaredType) targetType;

       JMethod jsConstructor = JjsUtils.getJsNativeConstructorOrNull(declaredType);
       assert jsConstructor != null &&  declaredType.isJsNative();
       call.addArg(new JsniMethodRef(sourceInfo, declaredType.getQualifiedJsName(), jsConstructor,
           program.getJavaScriptObject()));
       return call;
     } else {
       throw new AssertionError();
     }
   }

   public static void exec(JProgram program, boolean pruneTrivialCasts) {
     new ImplementCastsAndTypeChecks(program, pruneTrivialCasts).execImpl();
   }

   public static void exec(JProgram program) {
     new ImplementCastsAndTypeChecks(program, true).execImpl();
   }

   private final boolean pruneTrivialCasts;
   private final JProgram program;

   private Map<TypeCategory, JMethod> instanceOfMethodsByTargetTypeCategory =
       Maps.newEnumMap(TypeCategory.class);

   private Map<TypeCategory, JMethod> dynamicCastMethodsByTargetTypeCategory =
       Maps.newEnumMap(TypeCategory.class);

   private ImplementCastsAndTypeChecks(JProgram program, boolean pruneTrivialCasts) {
     this.program = program;
     this.pruneTrivialCasts = pruneTrivialCasts;

     for (TypeCategory t : TypeCategory.values()) {
       String castInstanceOfQualifier = t.castInstanceOfQualifier();
       if (castInstanceOfQualifier == null) {
         continue;
       }
       String instanceOfMethod = "Cast.instanceOf" + castInstanceOfQualifier;
       instanceOfMethodsByTargetTypeCategory.put(t, program.getIndexedMethod(instanceOfMethod));
       String castMethod = "Cast.castTo" + castInstanceOfQualifier;
       dynamicCastMethodsByTargetTypeCategory.put(t, program.getIndexedMethod(castMethod));
     }
   }

   private void execImpl() {
     new ReplaceTypeChecksVisitor().accept(program);
   }
 }
	/*
	* Copyright 2008 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.jjs.impl;

	import com.google.gwt.dev.jjs.SourceInfo;
	import com.google.gwt.dev.jjs.ast.Context;
	import com.google.gwt.dev.jjs.ast.JArrayType;
	import com.google.gwt.dev.jjs.ast.JBinaryOperation;
	import com.google.gwt.dev.jjs.ast.JBinaryOperator;
	import com.google.gwt.dev.jjs.ast.JCastOperation;
	import com.google.gwt.dev.jjs.ast.JDeclaredType;
	import com.google.gwt.dev.jjs.ast.JExpression;
	import com.google.gwt.dev.jjs.ast.JInstanceOf;
	import com.google.gwt.dev.jjs.ast.JInterfaceType;
	import com.google.gwt.dev.jjs.ast.JMethod;
	import com.google.gwt.dev.jjs.ast.JMethodCall;
	import com.google.gwt.dev.jjs.ast.JModVisitor;
	import com.google.gwt.dev.jjs.ast.JPrimitiveType;
	import com.google.gwt.dev.jjs.ast.JProgram;
	import com.google.gwt.dev.jjs.ast.JReferenceType;
	import com.google.gwt.dev.jjs.ast.JRuntimeTypeReference;
	import com.google.gwt.dev.jjs.ast.JType;
	import com.google.gwt.dev.jjs.ast.RuntimeConstants;
	import com.google.gwt.dev.jjs.ast.js.JsniMethodRef;
	import com.google.gwt.thirdparty.guava.common.collect.Maps;

	import java.util.Map;

	/**
	* Replace cast and instanceof operations with calls to the Cast class. Depends
	* on {@link CatchBlockNormalizer}, {@link CompoundAssignmentNormalizer},
	* {@link Devirtualizer}, and {@link LongCastNormalizer} having already run.
	* <p>
	* May or may not prune trivial casts depending on configuration.
	*/
	public class ImplementCastsAndTypeChecks {

	/**
	* Replaces all casts and instanceof operations with calls to implementation
	* methods.
	*/
	private class ReplaceTypeChecksVisitor extends JModVisitor {

	@Override
	public void endVisit(JCastOperation x, Context ctx) {
	JType toType = x.getCastType();
	JExpression expr = x.getExpr();

	SourceInfo info = x.getSourceInfo();
	if (pruneTrivialCasts && toType.isNullType()) {
	/**
	* A null type cast is used as a placeholder value to indicate that the
	* user tried a cast that couldn't possibly work. Typically this means
	* either the statically resolvable arg type is incompatible with the
	* target type, or the target type was globally uninstantiable.
	*
	* See {@link TypeTightener.TightenTypesVisitor#endVisit(JCastOperation, Context)}
	*
	* We handle this cast by throwing a ClassCastException, unless the
	* argument is null.
	*/
	JMethod method = program.getIndexedMethod(
	RuntimeConstants.CAST_THROW_CLASS_CAST_EXCEPTION_UNLESS_NULL);
	// Note, we must update the method call to return the null type.
	JMethodCall call = new JMethodCall(info, null, method, expr);
	call.overrideReturnType(toType);
	ctx.replaceMe(call);
	return;
	}

	if (toType instanceof JReferenceType) {
	JExpression curExpr = expr;
	JReferenceType refType = (JReferenceType) toType.getUnderlyingType();
	JReferenceType argType = (JReferenceType) expr.getType();

	if (refType instanceof JArrayType) {
	// Arrays of any subclass of JavaScriptObject are considered arrays of JavaScriptObject
	// for casting and instanceof purposes.
	refType = (JReferenceType) program.normalizeJsoType(refType);
	}

	if (pruneTrivialCasts && program.typeOracle.castSucceedsTrivially(argType, refType) \|\|
	determineTypeCategoryForType(refType) == TypeCategory.TYPE_JAVA_LANG_OBJECT) {
	// just remove the cast
	ctx.replaceMe(curExpr);
	return;
	} else if (program.typeOracle.isEffectivelyJavaScriptObject(argType)
	&& program.typeOracle.isEffectivelyJavaScriptObject(refType)) {
	// leave the cast instance for Pruner/CFA, remove in GenJSAST
	return;
	}
	// A cast is still needed. Substitute the appropriate Cast implementation.
	ctx.replaceMe(implementCastOrInstanceOfOperation(x.getSourceInfo(), curExpr, refType,
	dynamicCastMethodsByTargetTypeCategory, true));
	return;
	}

	// It is a primitive type, perform the necessary coercion.

	assert toType.isPrimitiveType();
	/*
	* See JLS 5.1.3: if a cast narrows from one type to another, we must
	* call a narrowing conversion function. EXCEPTION: we currently have no
	* way to narrow double to float, so don't bother.
	*/
	JPrimitiveType tByte = program.getTypePrimitiveByte();
	JPrimitiveType tChar = program.getTypePrimitiveChar();
	JPrimitiveType tShort = program.getTypePrimitiveShort();
	JPrimitiveType tInt = program.getTypePrimitiveInt();
	JPrimitiveType tLong = program.getTypePrimitiveLong();
	JPrimitiveType tFloat = program.getTypePrimitiveFloat();
	JPrimitiveType tDouble = program.getTypePrimitiveDouble();
	JType fromType = expr.getType();

	String methodName = null;

	if (tLong == fromType && tLong != toType) {
	if (tByte == toType \|\| tShort == toType \|\| tChar == toType) {
	/*
	* We need a double call here, one to convert long->int, and another
	* one to narrow. Construct the inner call here and fall through to
	* do the narrowing conversion.
	*/
	JMethod castMethod = program.getIndexedMethod(RuntimeConstants.LONG_LIB_TO_INT);
	JMethodCall call = new JMethodCall(info, null, castMethod);
	call.addArg(expr);
	expr = call;
	fromType = tInt;
	} else if (tInt == toType) {
	methodName = RuntimeConstants.LONG_LIB_TO_INT;
	} else if (tFloat == toType \|\| tDouble == toType) {
	methodName = RuntimeConstants.LONG_LIB_TO_DOUBLE;
	}
	}

	if (toType == tLong && fromType != tLong) {
	// Longs get special treatment.
	if (tByte == fromType \|\| tShort == fromType \|\| tChar == fromType \|\| tInt == fromType) {
	methodName = RuntimeConstants.LONG_LIB_FROM_INT;
	} else if (tFloat == fromType \|\| tDouble == fromType) {
	methodName = RuntimeConstants.LONG_LIB_FROM_DOUBLE;
	}
	} else if (tByte == fromType) {
	if (tChar == toType) {
	methodName = "Cast.narrow_" + toType.getName();
	}
	} else if (tShort == fromType) {
	if (tByte == toType \|\| tChar == toType) {
	methodName = "Cast.narrow_" + toType.getName();
	}
	} else if (tChar == fromType) {
	if (tByte == toType \|\| tShort == toType) {
	methodName = "Cast.narrow_" + toType.getName();
	}
	} else if (tInt == fromType) {
	if (tByte == toType \|\| tShort == toType \|\| tChar == toType) {
	methodName = "Cast.narrow_" + toType.getName();
	}
	} else if (tFloat == fromType \|\| tDouble == fromType) {
	if (tByte == toType \|\| tShort == toType \|\| tChar == toType \|\| tInt == toType) {
	methodName = "Cast.round_" + toType.getName();
	}
	}

	if (methodName != null) {
	JMethod castMethod = program.getIndexedMethod(methodName);
	JMethodCall call = new JMethodCall(info, null, castMethod, expr);
	call.overrideReturnType(toType);
	ctx.replaceMe(call);
	} else {
	// Just remove the cast
	ctx.replaceMe(expr);
	}
	}

	@Override
	public void endVisit(JInstanceOf x, Context ctx) {
	JReferenceType argType = (JReferenceType) x.getExpr().getType();
	JReferenceType toType = x.getTestType();
	// Only tests on run-time types are supported
	assert (toType == toType.getUnderlyingType());

	if (toType instanceof JArrayType) {
	// Arrays of any subclass of JavaScriptObject are considered arrays of JavaScriptObject
	// for casting and instanceof purposes.
	toType = (JReferenceType) program.normalizeJsoType(toType);
	}

	assert !toType.isJsNative() \|\| !(toType instanceof JInterfaceType);

	boolean isTrivialCast = program.typeOracle.castSucceedsTrivially(argType, toType)
	// don't depend on type-tightener having run
	\|\| (program.typeOracle.isEffectivelyJavaScriptObject(argType)
	&& program.typeOracle.isEffectivelyJavaScriptObject(toType));
	if (pruneTrivialCasts && isTrivialCast \|\|
	determineTypeCategoryForType(toType) == TypeCategory.TYPE_JAVA_LANG_OBJECT) {
	// trivially true if non-null; replace with a null test
	JBinaryOperation eq =
	new JBinaryOperation(x.getSourceInfo(), program.getTypePrimitiveBoolean(),
	JBinaryOperator.NEQ, x.getExpr(), program.getLiteralNull());
	ctx.replaceMe(eq);
	} else {
	// Replace the instance of check by a call to the appropriate instanceof method in class
	// Cast.
	ctx.replaceMe(implementCastOrInstanceOfOperation(x.getSourceInfo(), x.getExpr(), toType,
	instanceOfMethodsByTargetTypeCategory, false));
	}
	}
	}

	/**
	* Determines the type category for a specific reference type.
	*/
	private TypeCategory determineTypeCategoryForType(JReferenceType type) {
	TypeCategory typeCategory = TypeCategory.typeCategoryForType(type, program);

	assert typeCategory.castInstanceOfQualifier() != null;

	return typeCategory;
	}

	/**
	* Returns an expression implementing the instanceof/dynamicCast operations.
	*/
	private JMethodCall implementCastOrInstanceOfOperation(SourceInfo sourceInfo,
	JExpression targetExpression, JReferenceType targetType,
	Map<TypeCategory, JMethod> targetMethodByTypeCategory, boolean overrideReturnType) {

	TypeCategory targetTypeCategory = determineTypeCategoryForType(targetType);
	JMethod method = targetMethodByTypeCategory.get(targetTypeCategory);
	assert method != null;
	JMethodCall call = new JMethodCall(sourceInfo, null, method);
	if (overrideReturnType) {
	// Create a method call overriding the return type so that operations like Cast.dynamicCast
	// don't change the type of the original method call expression.
	call.overrideReturnType(targetType);
	}

	call.addArg(targetExpression);

	if (method.getParams().size() < 2) {
	// The cast checking method does not require an additional parameter. This situation arises
	// when the call is a cast check and cast checking has been disabled or when the type category
	// provides enough information, e.g. TYPE_UNTYPED_ARRAY.
	return call;
	} else if (targetTypeCategory.requiresTypeId()) {
	call.addArg((new JRuntimeTypeReference(sourceInfo, program.getTypeJavaLangObject(),
	targetType)));
	return call;
	} else if (targetTypeCategory.requiresJsConstructor()) {
	JDeclaredType declaredType = (JDeclaredType) targetType;

	JMethod jsConstructor = JjsUtils.getJsNativeConstructorOrNull(declaredType);
	assert jsConstructor != null && declaredType.isJsNative();
	call.addArg(new JsniMethodRef(sourceInfo, declaredType.getQualifiedJsName(), jsConstructor,
	program.getJavaScriptObject()));
	return call;
	} else {
	throw new AssertionError();
	}
	}

	public static void exec(JProgram program, boolean pruneTrivialCasts) {
	new ImplementCastsAndTypeChecks(program, pruneTrivialCasts).execImpl();
	}

	public static void exec(JProgram program) {
	new ImplementCastsAndTypeChecks(program, true).execImpl();
	}

	private final boolean pruneTrivialCasts;
	private final JProgram program;

	private Map<TypeCategory, JMethod> instanceOfMethodsByTargetTypeCategory =
	Maps.newEnumMap(TypeCategory.class);

	private Map<TypeCategory, JMethod> dynamicCastMethodsByTargetTypeCategory =
	Maps.newEnumMap(TypeCategory.class);

	private ImplementCastsAndTypeChecks(JProgram program, boolean pruneTrivialCasts) {
	this.program = program;
	this.pruneTrivialCasts = pruneTrivialCasts;

	for (TypeCategory t : TypeCategory.values()) {
	String castInstanceOfQualifier = t.castInstanceOfQualifier();
	if (castInstanceOfQualifier == null) {
	continue;
	}
	String instanceOfMethod = "Cast.instanceOf" + castInstanceOfQualifier;
	instanceOfMethodsByTargetTypeCategory.put(t, program.getIndexedMethod(instanceOfMethod));
	String castMethod = "Cast.castTo" + castInstanceOfQualifier;
	dynamicCastMethodsByTargetTypeCategory.put(t, program.getIndexedMethod(castMethod));
	}
	}

	private void execImpl() {
	new ReplaceTypeChecksVisitor().accept(program);
	}
	}