/*
* 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.SourceOrigin;
import com.google.gwt.dev.jjs.ast.Context;
import com.google.gwt.dev.jjs.ast.JArrayRef;
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.JCharLiteral;
import com.google.gwt.dev.jjs.ast.JClassType;
import com.google.gwt.dev.jjs.ast.JExpression;
import com.google.gwt.dev.jjs.ast.JInstanceOf;
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.JNullLiteral;
import com.google.gwt.dev.jjs.ast.JNullType;
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.JType;
import com.google.gwt.dev.jjs.ast.JTypeOracle;
import com.google.gwt.dev.jjs.ast.JVisitor;
import com.google.gwt.dev.jjs.ast.js.JsCastMap;
import com.google.gwt.dev.jjs.ast.js.JsCastMap.JsQueryType;
import com.google.gwt.dev.util.collect.Lists;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
/**
* Replace cast and instanceof operations with calls to the Cast class. Depends
* on {@link CatchBlockNormalizer}, {@link CompoundAssignmentNormalizer},
* {@link JsoDevirtualizer}, and {@link LongCastNormalizer} having already run.
*
* <p>
* Object and String always get a queryId of 0 and 1, respectively. The 0
* queryId always means "always succeeds". In practice, we never generate an
* explicit cast with a queryId of 0; it is only used for array store checking,
* where the 0 queryId means that anything can be stored into an Object[].
* </p>
* <p>
* JavaScriptObject has a queryId of -1, which again is only used for array
* store checking, to ensure that a non-JSO is not stored into a
* JavaScriptObject[].
* </p>
*/
public class CastNormalizer {
private class AssignTypeCastabilityVisitor extends JVisitor {
private final Set<JReferenceType> alreadyRan = new HashSet<JReferenceType>();
private final IdentityHashMap<JReferenceType, JsCastMap> castableTypesMap =
new IdentityHashMap<JReferenceType, JsCastMap>();
private final List<JArrayType> instantiatedArrayTypes = new ArrayList<JArrayType>();
private final Map<JReferenceType, Set<JReferenceType>> queriedTypes =
new IdentityHashMap<JReferenceType, Set<JReferenceType>>();
{
JTypeOracle typeOracle = program.typeOracle;
for (JArrayType arrayType : program.getAllArrayTypes()) {
if (typeOracle.isInstantiatedType(arrayType)) {
instantiatedArrayTypes.add(arrayType);
}
}
// Force entries for Object and String.
recordCastInternal(program.getTypeJavaLangObject(), program.getTypeJavaLangObject());
recordCastInternal(program.getTypeJavaLangString(), program.getTypeJavaLangObject());
}
public void computeTypeCastabilityMaps() {
List<JReferenceType> sortedQueryTypes = sortQueryTypes();
queryIdsByType = assignQueryIds(sortedQueryTypes);
// do String first (which will pull in Object also, it's superclass).
computeSourceType(program.getTypeJavaLangString());
assert (castableTypesMap.size() == 2);
/*
* Compute the list of classes than can successfully satisfy cast
* requests, along with the set of types they can be successfully cast to.
* Do it in super type order.
*/
for (JReferenceType type : program.getDeclaredTypes()) {
if (type instanceof JClassType) {
computeSourceType(type);
}
}
for (JArrayType type : instantiatedArrayTypes) {
computeSourceType(type);
}
// pass our info to JProgram
program.initTypeInfo(castableTypesMap);
program.recordQueryIds(queryIdsByType, sortedQueryTypes);
}
/*
* If this expression could possibly generate an ArrayStoreException, we
* must record a query on the element type being assigned to.
*/
@Override
public void endVisit(JBinaryOperation x, Context ctx) {
if (x.getOp().isAssignment() && x.getLhs() instanceof JArrayRef) {
// first, calculate the transitive closure of all possible runtime types
// the lhs could be
JArrayRef lhsArrayRef = (JArrayRef) x.getLhs();
JType elementType = lhsArrayRef.getType();
if (elementType instanceof JNullType) {
// will generate a null pointer exception instead
return;
}
// primitives are statically correct
if (!(elementType instanceof JReferenceType)) {
return;
}
// element type being final means the assignment is statically correct
if (((JReferenceType) elementType).isFinal()) {
return;
}
/*
* For every instantiated array type that could -in theory- be the
* runtime type of the lhs, we must record a cast from the rhs to the
* prospective element type of the lhs.
*/
JTypeOracle typeOracle = program.typeOracle;
JType rhsType = x.getRhs().getType();
assert (rhsType instanceof JReferenceType);
JArrayType lhsArrayType = lhsArrayRef.getArrayType();
for (JArrayType arrayType : instantiatedArrayTypes) {
if (typeOracle.canTheoreticallyCast(arrayType, lhsArrayType)) {
JType itElementType = arrayType.getElementType();
if (itElementType instanceof JReferenceType) {
recordCast(itElementType, x.getRhs());
}
}
}
}
}
@Override
public void endVisit(JCastOperation x, Context ctx) {
if (disableCastChecking) {
return;
}
if (x.getCastType() != program.getTypeNull()) {
recordCast(x.getCastType(), x.getExpr());
}
}
@Override
public void endVisit(JInstanceOf x, Context ctx) {
assert (x.getTestType() != program.getTypeNull());
recordCast(x.getTestType(), x.getExpr());
}
private Map<JReferenceType, Integer> assignQueryIds(List<JReferenceType> sortedQueryTypes) {
Map<JReferenceType, Integer> result = new IdentityHashMap<JReferenceType, Integer>();
int queryId = 0;
for (JReferenceType queryType : sortedQueryTypes) {
result.put(queryType, queryId++);
}
// JSO's marker queryId is -1 (used for array stores).
JClassType jsoType = program.getJavaScriptObject();
if (jsoType != null) {
result.put(jsoType, -1);
}
return result;
}
private boolean canTriviallyCastJsoSemantics(JReferenceType type, JReferenceType qType) {
type = type.getUnderlyingType();
qType = qType.getUnderlyingType();
if (type instanceof JArrayType && qType instanceof JArrayType) {
JArrayType aType = (JArrayType) type;
JArrayType aqType = (JArrayType) qType;
return program.typeOracle.canTriviallyCast(type, qType)
|| (program.isJavaScriptObject(aType.getLeafType()) && program
.isJavaScriptObject(aqType.getLeafType()));
}
return program.typeOracle.canTriviallyCast(type, qType)
|| (program.isJavaScriptObject(type) && program.isJavaScriptObject(qType));
}
/**
* Create the data for JSON table to capture the mapping from a class to its
* query types.
*/
private void computeSourceType(JReferenceType type) {
if (type == null || alreadyRan.contains(type)) {
return;
}
assert (type == type.getUnderlyingType());
alreadyRan.add(type);
// Visit super type.
if (type instanceof JClassType) {
computeSourceType(((JClassType) type).getSuperClass());
}
if (!program.typeOracle.isInstantiatedType(type) || program.isJavaScriptObject(type)) {
return;
}
// Find all possible query types which I can satisfy
Set<JsQueryType> castableTypes = new TreeSet<JsQueryType>(JSQUERY_COMPARATOR);
/*
* NOTE: non-deterministic iteration over HashSet and HashMap. Okay
* because we're sorting the results.
*/
for (JReferenceType qType : queriedTypes.keySet()) {
Set<JReferenceType> querySet = queriedTypes.get(qType);
/**
* Handles JSO[] -> JSO[] case now that canCastTrivially doesn't deal
* with JSO cross-casts anymore.
*/
if (canTriviallyCastJsoSemantics(type, qType)) {
for (JReferenceType argType : querySet) {
if (canTriviallyCastJsoSemantics(type, argType) || program.isJavaScriptObject(qType)) {
int queryId = queryIdsByType.get(qType);
// Ignore Object (id 0) which is always true.
if (queryId > 0) {
castableTypes.add(new JsQueryType(SourceOrigin.UNKNOWN, qType, queryId));
}
break;
}
}
}
}
/*
* Don't add an entry for empty answer sets, except for Object and String
* which require entries.
*/
if (castableTypes.isEmpty() && type != program.getTypeJavaLangObject()
&& type != program.getTypeJavaLangString()) {
return;
}
// add an entry for me
castableTypesMap.put(type, new JsCastMap(SourceOrigin.UNKNOWN, Lists.create(castableTypes),
program.getJavaScriptObject()));
}
private void recordCast(JType targetType, JExpression rhs) {
if (targetType instanceof JReferenceType) {
targetType = ((JReferenceType) targetType).getUnderlyingType();
// unconditional cast b/c it would've been a semantic error earlier
JReferenceType rhsType = ((JReferenceType) rhs.getType()).getUnderlyingType();
// don't record a type for trivial casts that won't generate code
if (program.typeOracle.canTriviallyCast(rhsType, (JReferenceType) targetType)) {
return;
}
// If the target type is a JavaScriptObject, don't record an id.
if (program.isJavaScriptObject(targetType)) {
return;
}
recordCastInternal((JReferenceType) targetType, rhsType);
}
}
private void recordCastInternal(JReferenceType toType, JReferenceType rhsType) {
toType = toType.getUnderlyingType();
rhsType = rhsType.getUnderlyingType();
Set<JReferenceType> querySet = queriedTypes.get(toType);
if (querySet == null) {
querySet = new HashSet<JReferenceType>();
queriedTypes.put(toType, querySet);
}
querySet.add(rhsType);
}
/**
* Sort into alphabetical, except Object and String which must come first.
*/
private List<JReferenceType> sortQueryTypes() {
// Initial name-only sort.
List<JReferenceType> sortedQueryTypes = new ArrayList<JReferenceType>(queriedTypes.keySet());
Collections.sort(sortedQueryTypes, new HasNameSort());
// Used LinkedHashSet to move Object and String to the front.
LinkedHashSet<JReferenceType> tempSortedQueryTypes = new LinkedHashSet<JReferenceType>();
// Reserve query id 0 for java.lang.Object (for array stores on JSOs).
tempSortedQueryTypes.add(program.getTypeJavaLangObject());
/*
* Reserve query id 1 for java.lang.String to facilitate the mashup case.
* Also, facilitates detecting an object as a Java String (see Cast.java)
* Multiple GWT modules need to modify String's prototype the same way.
*/
tempSortedQueryTypes.add(program.getTypeJavaLangString());
// Add the rest.
tempSortedQueryTypes.addAll(sortedQueryTypes);
sortedQueryTypes = new ArrayList<JReferenceType>(tempSortedQueryTypes);
return sortedQueryTypes;
}
}
/**
* Explicitly convert any char or long type expressions within a concat
* operation into strings because normal JavaScript conversion does not work
* correctly.
*/
private class ConcatVisitor extends JModVisitor {
@Override
public void endVisit(JBinaryOperation x, Context ctx) {
if (x.getOp() == JBinaryOperator.CONCAT) {
JExpression newLhs = convertString(x.getLhs());
JExpression newRhs = convertString(x.getRhs());
if (newLhs != x.getLhs() || newRhs != x.getRhs()) {
JBinaryOperation newExpr =
new JBinaryOperation(x.getSourceInfo(), program.getTypeJavaLangString(),
JBinaryOperator.CONCAT, newLhs, newRhs);
ctx.replaceMe(newExpr);
}
} else if (x.getOp() == JBinaryOperator.ASG_CONCAT) {
JExpression newRhs = convertString(x.getRhs());
if (newRhs != x.getRhs()) {
JBinaryOperation newExpr =
new JBinaryOperation(x.getSourceInfo(), program.getTypeJavaLangString(),
JBinaryOperator.ASG_CONCAT, x.getLhs(), newRhs);
ctx.replaceMe(newExpr);
}
}
}
private JExpression convertString(JExpression expr) {
JPrimitiveType charType = program.getTypePrimitiveChar();
if (expr.getType() == charType) {
if (expr instanceof JCharLiteral) {
JCharLiteral charLit = (JCharLiteral) expr;
return program.getLiteralString(expr.getSourceInfo(), new char[]{charLit.getValue()});
} else {
// Replace with Cast.charToString(c)
JMethodCall call =
new JMethodCall(expr.getSourceInfo(), null, program
.getIndexedMethod("Cast.charToString"));
call.addArg(expr);
return call;
}
} else if (expr.getType() == program.getTypePrimitiveLong()) {
// Replace with LongLib.toString(l)
JMethodCall call =
new JMethodCall(expr.getSourceInfo(), null, program
.getIndexedMethod("LongLib.toString"));
call.addArg(expr);
return call;
}
return expr;
}
}
/**
* Handle integral divide operations which may have floating point results.
*/
private class DivVisitor extends JModVisitor {
@Override
public void endVisit(JBinaryOperation x, Context ctx) {
JType type = x.getType();
if (x.getOp() == JBinaryOperator.DIV && type != program.getTypePrimitiveFloat()
&& type != program.getTypePrimitiveDouble()) {
/*
* If the numerator was already in range, we can assume the output is
* also in range. Therefore, we don't need to do the full conversion,
* but rather a narrowing int conversion instead.
*/
String methodName = "Cast.narrow_" + type.getName();
JMethod castMethod = program.getIndexedMethod(methodName);
JMethodCall call = new JMethodCall(x.getSourceInfo(), null, castMethod, type);
x.setType(program.getTypePrimitiveDouble());
call.addArg(x);
ctx.replaceMe(call);
}
}
}
/**
* Replaces all casts and instanceof operations with calls to implementation
* methods.
*/
private class ReplaceTypeChecksVisitor extends JModVisitor {
@Override
public void endVisit(JCastOperation x, Context ctx) {
JExpression replaceExpr;
JType toType = x.getCastType();
JExpression expr = x.getExpr();
if (disableCastChecking && toType instanceof JReferenceType) {
// Just leave the cast in, GenerateJavaScriptAST will ignore it.
return;
}
SourceInfo info = x.getSourceInfo();
if (toType instanceof JNullType) {
/**
* 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 com.google.gwt.dev.jjs.impl.TypeTightener.TightenTypesVisitor#endVisit(JCastOperation,
* Context)}
*
* We handle this cast by throwing a ClassCastException, unless the
* argument is null.
*/
JMethod method = program.getIndexedMethod("Cast.throwClassCastExceptionUnlessNull");
// Note, we must update the method call to return the null type.
JMethodCall call = new JMethodCall(info, null, method, toType);
call.addArg(expr);
replaceExpr = call;
} else if (toType instanceof JReferenceType) {
JExpression curExpr = expr;
JReferenceType refType = ((JReferenceType) toType).getUnderlyingType();
JReferenceType argType = (JReferenceType) expr.getType();
if (program.typeOracle.canTriviallyCast(argType, refType)
|| (program.typeOracle.isEffectivelyJavaScriptObject(argType) && program.typeOracle
.isEffectivelyJavaScriptObject(refType))) {
// just remove the cast
replaceExpr = curExpr;
} else {
// A cast is still needed. Substitute the appropriate Cast implementation.
JMethod method;
boolean isJsoCast = program.typeOracle.isEffectivelyJavaScriptObject(refType);
if (isJsoCast) {
// A cast to a concrete JSO subtype
method = program.getIndexedMethod("Cast.dynamicCastJso");
} else if (program.typeOracle.isDualJsoInterface(refType)) {
// An interface that should succeed when the object is a JSO
method = program.getIndexedMethod("Cast.dynamicCastAllowJso");
} else {
// A regular cast
method = program.getIndexedMethod("Cast.dynamicCast");
}
// override the type of the called method with the target cast type
JMethodCall call = new JMethodCall(info, null, method, toType);
call.addArg(curExpr);
if (!isJsoCast) {
call.addArg(new JsQueryType(info, refType, queryIdsByType.get(refType)));
}
replaceExpr = call;
}
} else {
/*
* 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("LongLib.toInt");
JMethodCall call = new JMethodCall(info, null, castMethod);
call.addArg(expr);
expr = call;
fromType = tInt;
} else if (tInt == toType) {
methodName = "LongLib.toInt";
} else if (tFloat == toType || tDouble == toType) {
methodName = "LongLib.toDouble";
}
}
if (toType == tLong && fromType != tLong) {
// Longs get special treatment.
if (tByte == fromType || tShort == fromType || tChar == fromType || tInt == fromType) {
methodName = "LongLib.fromInt";
} else if (tFloat == fromType || tDouble == fromType) {
methodName = "LongLib.fromDouble";
}
} 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, toType);
call.addArg(expr);
replaceExpr = call;
} else {
// Just remove the cast
replaceExpr = expr;
}
}
ctx.replaceMe(replaceExpr);
}
@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 (program.typeOracle.canTriviallyCast(argType, toType)
// don't depend on type-tightener having run
|| (program.typeOracle.isEffectivelyJavaScriptObject(argType) && program.typeOracle
.isEffectivelyJavaScriptObject(toType))) {
// trivially true if non-null; replace with a null test
JNullLiteral nullLit = program.getLiteralNull();
JBinaryOperation eq =
new JBinaryOperation(x.getSourceInfo(), program.getTypePrimitiveBoolean(),
JBinaryOperator.NEQ, x.getExpr(), nullLit);
ctx.replaceMe(eq);
} else {
JMethod method;
boolean isJsoCast = false;
if (program.typeOracle.isDualJsoInterface(toType)) {
method = program.getIndexedMethod("Cast.instanceOfOrJso");
} else if (program.typeOracle.isEffectivelyJavaScriptObject(toType)) {
isJsoCast = true;
method = program.getIndexedMethod("Cast.instanceOfJso");
} else {
method = program.getIndexedMethod("Cast.instanceOf");
}
JMethodCall call = new JMethodCall(x.getSourceInfo(), null, method);
call.addArg(x.getExpr());
if (!isJsoCast) {
call.addArg(new JsQueryType(x.getSourceInfo(), toType, queryIdsByType.get(toType)));
}
ctx.replaceMe(call);
}
}
}
private static final Comparator<JsQueryType> JSQUERY_COMPARATOR = new Comparator<JsQueryType>() {
@Override
public int compare(JsQueryType o1, JsQueryType o2) {
return o1.getQueryId() - o2.getQueryId();
}
};
public static void exec(JProgram program, boolean disableCastChecking) {
new CastNormalizer(program, disableCastChecking).execImpl();
}
private final boolean disableCastChecking;
private final JProgram program;
private Map<JReferenceType, Integer> queryIdsByType;
private CastNormalizer(JProgram program, boolean disableCastChecking) {
this.program = program;
this.disableCastChecking = disableCastChecking;
}
private void execImpl() {
{
ConcatVisitor visitor = new ConcatVisitor();
visitor.accept(program);
}
{
DivVisitor visitor = new DivVisitor();
visitor.accept(program);
}
{
AssignTypeCastabilityVisitor assigner = new AssignTypeCastabilityVisitor();
assigner.accept(program);
assigner.computeTypeCastabilityMaps();
}
{
ReplaceTypeChecksVisitor replacer = new ReplaceTypeChecksVisitor();
replacer.accept(program);
}
}
}