1.5 cleanup
Patch by: bobv
Review by: me
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@1530 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java b/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java
index 6acea50..b878e53 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/impl/TypeTightener.java
@@ -83,17 +83,19 @@
* can't figure out that tightening might occur.
*
* Type flow is not supported for primitive types, only reference types.
- *
- * TODO(later): handle recursion, self-assignment, arrays
*/
public class TypeTightener {
+ /*
+ * TODO(later): handle recursion, self-assignment, arrays, method tightening
+ * on invocations from within JSNI blocks
+ */
/**
* Replaces dangling null references with dummy calls.
*/
public class FixDanglingRefsVisitor extends JModVisitor {
- // @Override
+ @Override
public void endVisit(JArrayRef x, Context ctx) {
JExpression instance = x.getInstance();
if (instance.getType() == typeNull) {
@@ -106,7 +108,7 @@
}
}
- // @Override
+ @Override
public void endVisit(JFieldRef x, Context ctx) {
JExpression instance = x.getInstance();
boolean isStatic = x.getField().isStatic();
@@ -128,7 +130,7 @@
}
}
- // @Override
+ @Override
public void endVisit(JMethodCall x, Context ctx) {
JExpression instance = x.getInstance();
JMethod method = x.getTarget();
@@ -152,9 +154,9 @@
instance, program.getNullMethod());
ctx.replaceMe(newCall);
} else if (isStaticImpl && x.getArgs().size() > 0
- && ((JExpression) x.getArgs().get(0)).getType() == typeNull) {
+ && x.getArgs().get(0).getType() == typeNull) {
// bind null instance calls to the null method for static impls
- instance = (JExpression) x.getArgs().get(0);
+ instance = x.getArgs().get(0);
if (!instance.hasSideEffects()) {
instance = program.getLiteralNull();
}
@@ -183,7 +185,7 @@
private JMethod currentMethod;
- // @Override
+ @Override
public void endVisit(JBinaryOperation x, Context ctx) {
if (x.isAssignment() && (x.getType() instanceof JReferenceType)) {
JExpression lhs = x.getLhs();
@@ -193,18 +195,17 @@
}
}
- // @Override
+ @Override
public void endVisit(JClassType x, Context ctx) {
for (JClassType cur = x; cur != null; cur = cur.extnds) {
addImplementor(cur, x);
- for (Iterator it = cur.implments.iterator(); it.hasNext();) {
- JInterfaceType implment = (JInterfaceType) it.next();
+ for (JInterfaceType implment : cur.implments) {
addImplementor(implment, x);
}
}
}
- // @Override
+ @Override
public void endVisit(JField x, Context ctx) {
if (x.constInitializer != null) {
addAssignment(x, x.constInitializer);
@@ -212,7 +213,7 @@
currentMethod = null;
}
- // @Override
+ @Override
public void endVisit(JLocalDeclarationStatement x, Context ctx) {
JExpression initializer = x.getInitializer();
if (initializer != null) {
@@ -220,66 +221,62 @@
}
}
- // @Override
+ @Override
public void endVisit(JMethod x, Context ctx) {
- for (int i = 0; i < x.overrides.size(); ++i) {
- JMethod method = (JMethod) x.overrides.get(i);
+ for (JMethod method : x.overrides) {
addOverrider(method, x);
}
JMethod[] allVirtualOverrides = program.typeOracle.getAllVirtualOverrides(x);
- for (int i = 0; i < allVirtualOverrides.length; ++i) {
- JMethod method = allVirtualOverrides[i];
+ for (JMethod method : allVirtualOverrides) {
addOverrider(method, x);
}
currentMethod = null;
}
- // @Override
+ @Override
public void endVisit(JMethodCall x, Context ctx) {
// All of the params in the target method are considered to be assigned by
// the arguments from the caller
- Iterator/* <JExpression> */argIt = x.getArgs().iterator();
- ArrayList params = x.getTarget().params;
+ Iterator<JExpression> argIt = x.getArgs().iterator();
+ ArrayList<JParameter> params = x.getTarget().params;
for (int i = 0; i < params.size(); ++i) {
- JParameter param = (JParameter) params.get(i);
- JExpression arg = (JExpression) argIt.next();
+ JParameter param = params.get(i);
+ JExpression arg = argIt.next();
if (param.getType() instanceof JReferenceType) {
addAssignment(param, arg);
}
}
}
- // @Override
+ @Override
public void endVisit(JReturnStatement x, Context ctx) {
if (currentMethod.getType() instanceof JReferenceType) {
addReturn(currentMethod, x.getExpr());
}
}
- // @Override
+ @Override
public void endVisit(JsniFieldRef x, Context ctx) {
// If this happens in JSNI, we can't make any type-tightening assumptions
// Fake an assignment-to-self to prevent tightening
addAssignment(x.getTarget(), x);
}
- // @Override
+ @Override
public void endVisit(JsniMethodRef x, Context ctx) {
// If this happens in JSNI, we can't make any type-tightening assumptions
// Fake an assignment-to-self on all args to prevent tightening
JMethod method = x.getTarget();
- for (int i = 0; i < method.params.size(); ++i) {
- JParameter param = (JParameter) method.params.get(i);
+ for (JParameter param : method.params) {
addAssignment(param, new JParameterRef(program, null, param));
}
}
- // @Override
+ @Override
public void endVisit(JTryStatement x, Context ctx) {
// Never tighten args to catch blocks
// Fake an assignment-to-self to prevent tightening
- for (int i = 0; i < x.getCatchArgs().size(); ++i) {
- JLocalRef arg = (JLocalRef) x.getCatchArgs().get(i);
+ for (JLocalRef arg : x.getCatchArgs()) {
addAssignment(arg.getTarget(), arg);
}
}
@@ -288,11 +285,11 @@
* Merge param call args across overriders/implementors. We can't tighten a
* param type in an overriding method if the declaring method is looser.
*/
- // @Override
+ @Override
public boolean visit(JMethod x, Context ctx) {
currentMethod = x;
- List/* <JMethod> */overrides = x.overrides;
+ List<JMethod> overrides = x.overrides;
JMethod[] virtualOverrides = program.typeOracle.getAllVirtualOverrides(x);
/*
@@ -318,25 +315,25 @@
}
for (int j = 0, c = x.params.size(); j < c; ++j) {
- JParameter param = (JParameter) x.params.get(j);
- Set/* <JParameter> */set = (Set) paramUpRefs.get(param);
+ JParameter param = x.params.get(j);
+ Set<JParameter> set = paramUpRefs.get(param);
if (set == null) {
- set = new HashSet/* <JParameter> */();
+ set = new HashSet<JParameter>();
paramUpRefs.put(param, set);
}
for (int i = 0; i < overrides.size(); ++i) {
- JMethod baseMethod = (JMethod) overrides.get(i);
- JParameter baseParam = (JParameter) baseMethod.params.get(j);
+ JMethod baseMethod = overrides.get(i);
+ JParameter baseParam = baseMethod.params.get(j);
set.add(baseParam);
}
for (int i = 0; i < virtualOverrides.length; ++i) {
JMethod baseMethod = virtualOverrides[i];
- JParameter baseParam = (JParameter) baseMethod.params.get(j);
+ JParameter baseParam = baseMethod.params.get(j);
set.add(baseParam);
}
if (staticImplFor != null && j > 1) {
// static impls have an extra first "this" arg
- JParameter baseParam = (JParameter) staticImplFor.params.get(j - 1);
+ JParameter baseParam = staticImplFor.params.get(j - 1);
set.add(baseParam);
}
}
@@ -413,12 +410,12 @@
}
}
- // @Override
+ @Override
public void endVisit(JField x, Context ctx) {
tighten(x);
}
- // @Override
+ @Override
public void endVisit(JInstanceOf x, Context ctx) {
JType argType = x.getExpr().getType();
if (!(argType instanceof JReferenceType)) {
@@ -434,7 +431,7 @@
JTypeOracle typeOracle = program.typeOracle;
if (fromType == program.getTypeNull()) {
- // null is never instanceOf anything
+ // null is never instanceof anything
triviallyFalse = true;
} else if (typeOracle.canTriviallyCast(fromType, toType)) {
triviallyTrue = true;
@@ -457,7 +454,7 @@
}
}
- // @Override
+ @Override
public void endVisit(JLocal x, Context ctx) {
tighten(x);
}
@@ -465,7 +462,7 @@
/**
* Tighten based on return types and overrides.
*/
- // @Override
+ @Override
public void endVisit(JMethod x, Context ctx) {
/*
* Explicitly NOT visiting native methods since we can't infer type
@@ -494,7 +491,7 @@
}
// tighten based on both returned types and possible overrides
- List/* <JReferenceType> */typeList = new ArrayList/* <JReferenceType> */();
+ List<JReferenceType> typeList = new ArrayList<JReferenceType>();
/*
* Always assume at least one null assignment; if there really aren't any
@@ -503,18 +500,16 @@
*/
typeList.add(typeNull);
- Set/* <JExpression> */myReturns = (Set) returns.get(x);
+ Set<JExpression> myReturns = returns.get(x);
if (myReturns != null) {
- for (Iterator iter = myReturns.iterator(); iter.hasNext();) {
- JExpression expr = (JExpression) iter.next();
- typeList.add(expr.getType());
+ for (JExpression expr : myReturns) {
+ typeList.add((JReferenceType) expr.getType());
}
}
- Set/* <JMethod> */myOverriders = (Set) overriders.get(x);
+ Set<JMethod> myOverriders = overriders.get(x);
if (myOverriders != null) {
- for (Iterator iter = myOverriders.iterator(); iter.hasNext();) {
- JMethod method = (JMethod) iter.next();
- typeList.add(method.getType());
+ for (JMethod method : myOverriders) {
+ typeList.add((JReferenceType) method.getType());
}
}
@@ -526,12 +521,12 @@
}
}
- // @Override
+ @Override
public void endVisit(JParameter x, Context ctx) {
tighten(x);
}
- // @Override
+ @Override
public boolean visit(JClassType x, Context ctx) {
// don't mess with classes used in code gen
if (program.codeGenTypes.contains(x)) {
@@ -571,7 +566,7 @@
}
// tighten based on assignment
- List/* <JReferenceType> */typeList = new ArrayList/* <JReferenceType> */();
+ List<JReferenceType> typeList = new ArrayList<JReferenceType>();
/*
* For non-parameters, always assume at least one null assignment; if
@@ -586,24 +581,22 @@
typeList.add(typeNull);
}
- Set/* <JExpression> */myAssignments = (Set) assignments.get(x);
+ Set<JExpression> myAssignments = assignments.get(x);
if (myAssignments != null) {
- for (Iterator iter = myAssignments.iterator(); iter.hasNext();) {
- JExpression expr = (JExpression) iter.next();
+ for (JExpression expr : myAssignments) {
JType type = expr.getType();
if (!(type instanceof JReferenceType)) {
return; // something fishy is going on, just abort
}
- typeList.add(type);
+ typeList.add((JReferenceType) type);
}
}
if (x instanceof JParameter) {
- Set/* <JParameter> */myParams = (Set) paramUpRefs.get(x);
+ Set<JParameter> myParams = paramUpRefs.get(x);
if (myParams != null) {
- for (Iterator iter = myParams.iterator(); iter.hasNext();) {
- JParameter param = (JParameter) iter.next();
- typeList.add(param.getType());
+ for (JParameter param : myParams) {
+ typeList.add((JReferenceType) param.getType());
}
}
}
@@ -625,22 +618,21 @@
return new TypeTightener(program).execImpl();
}
- private static/* <T, V> */void add(Object target, Object value,
- Map/* <T, Set<V>> */map) {
- Set/* <V> */set = (Set) map.get(target);
+ private static <T, V> void add(T target, V value, Map<T, Set<V>> map) {
+ Set<V> set = map.get(target);
if (set == null) {
- set = new HashSet/* <V> */();
+ set = new HashSet<V>();
map.put(target, set);
}
set.add(value);
}
- private final Map/* <JVariable, Set<JExpression>> */assignments = new IdentityHashMap();
- private final Map/* <JReferenceType, Set<JClassType>> */implementors = new IdentityHashMap();
- private final Map/* <JMethod, Set<JMethod>> */overriders = new IdentityHashMap();
- private final Map/* <JParameter, Set<JParameter>> */paramUpRefs = new IdentityHashMap();
+ private final Map<JVariable, Set<JExpression>> assignments = new IdentityHashMap<JVariable, Set<JExpression>>();
+ private final Map<JReferenceType, Set<JClassType>> implementors = new IdentityHashMap<JReferenceType, Set<JClassType>>();
+ private final Map<JMethod, Set<JMethod>> overriders = new IdentityHashMap<JMethod, Set<JMethod>>();
+ private final Map<JParameter, Set<JParameter>> paramUpRefs = new IdentityHashMap<JParameter, Set<JParameter>>();
private final JProgram program;
- private final Map/* <JMethod, Set<JExpression>> */returns = new IdentityHashMap();
+ private final Map<JMethod, Set<JExpression>> returns = new IdentityHashMap<JMethod, Set<JExpression>>();
private final JNullType typeNull;
private TypeTightener(JProgram program) {
@@ -653,7 +645,7 @@
recorder.accept(program);
/*
- * We must iterate mutiple times because each way point we tighten creates
+ * We must iterate multiple times because each way point we tighten creates
* more opportunities to do additional tightening for the things that depend
* on it.
*/
