Java 1.5 generification of JTypeOracle. git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@1644 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java b/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java index 184dd88..731306b 100644 --- a/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java +++ b/dev/core/src/com/google/gwt/dev/jjs/ast/JTypeOracle.java
@@ -19,7 +19,6 @@ import java.util.HashMap; import java.util.HashSet; import java.util.IdentityHashMap; -import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; @@ -29,31 +28,31 @@ */ public class JTypeOracle { - private final Map/* <JInterfaceType, Set<JClassType>> */couldBeImplementedMap = new IdentityHashMap(); + private final Map<JInterfaceType, Set<JClassType>> couldBeImplementedMap = new IdentityHashMap<JInterfaceType, Set<JClassType>>(); - private final Map/* <JClassType, Set<JInterfaceType>> */couldImplementMap = new IdentityHashMap(); + private final Map<JClassType, Set<JInterfaceType>> couldImplementMap = new IdentityHashMap<JClassType, Set<JInterfaceType>>(); - private final Set/* <JReferenceType> */hasClinitSet = new HashSet(); + private final Set<JReferenceType> hasClinitSet = new HashSet<JReferenceType>(); - private final Map/* <JClassType, Set<JInterfaceType>> */implementsMap = new IdentityHashMap(); + private final Map<JClassType, Set<JInterfaceType>> implementsMap = new IdentityHashMap<JClassType, Set<JInterfaceType>>(); - private final Set/* <JReferenceType> */instantiatedTypes = new HashSet(); + private final Set<JReferenceType> instantiatedTypes = new HashSet<JReferenceType>(); - private final Map/* <JInterfaceType, Set<JClassType>> */isImplementedMap = new IdentityHashMap(); + private final Map<JInterfaceType, Set<JClassType>> isImplementedMap = new IdentityHashMap<JInterfaceType, Set<JClassType>>(); private JClassType javaLangObject = null; private final JProgram program; - private final Map/* <JClassType, Set<JClassType>> */subClassMap = new IdentityHashMap(); + private final Map<JClassType, Set<JClassType>> subClassMap = new IdentityHashMap<JClassType, Set<JClassType>>(); - private final Map/* <JInterfaceType, Set<JInterfaceType>> */subInterfaceMap = new IdentityHashMap(); + private final Map<JInterfaceType, Set<JInterfaceType>> subInterfaceMap = new IdentityHashMap<JInterfaceType, Set<JInterfaceType>>(); - private final Map/* <JClassType, Set<JClassType>> */superClassMap = new IdentityHashMap(); + private final Map<JClassType, Set<JClassType>> superClassMap = new IdentityHashMap<JClassType, Set<JClassType>>(); - private final Map/* <JInterfaceType, Set<JInterfaceType>> */superInterfaceMap = new IdentityHashMap(); + private final Map<JInterfaceType, Set<JInterfaceType>> superInterfaceMap = new IdentityHashMap<JInterfaceType, Set<JInterfaceType>>(); - private final Map/* <JMethod, Map<JClassType, Set<JMethod>>> */virtualUpRefMap = new IdentityHashMap(); + private final Map<JMethod, Map<JClassType, Set<JMethod>>> virtualUpRefMap = new IdentityHashMap<JMethod, Map<JClassType, Set<JMethod>>>(); public JTypeOracle(JProgram program) { this.program = program; @@ -205,7 +204,7 @@ couldBeImplementedMap.clear(); for (int i = 0; i < program.getDeclaredTypes().size(); ++i) { - JReferenceType type = (JReferenceType) program.getDeclaredTypes().get(i); + JReferenceType type = program.getDeclaredTypes().get(i); if (type instanceof JClassType) { recordSuperSubInfo((JClassType) type); } else { @@ -213,19 +212,19 @@ } } for (int i = 0; i < program.getDeclaredTypes().size(); ++i) { - JReferenceType type = (JReferenceType) program.getDeclaredTypes().get(i); + JReferenceType type = program.getDeclaredTypes().get(i); if (type instanceof JClassType) { computeImplements((JClassType) type); } } for (int i = 0; i < program.getDeclaredTypes().size(); ++i) { - JReferenceType type = (JReferenceType) program.getDeclaredTypes().get(i); + JReferenceType type = program.getDeclaredTypes().get(i); if (type instanceof JClassType) { computeCouldImplement((JClassType) type); } } for (int i = 0; i < program.getDeclaredTypes().size(); ++i) { - JReferenceType type = (JReferenceType) program.getDeclaredTypes().get(i); + JReferenceType type = program.getDeclaredTypes().get(i); if (type instanceof JClassType) { computeVirtualUpRefs((JClassType) type); } @@ -240,20 +239,19 @@ } public JMethod[] getAllVirtualOverrides(JMethod method) { - Set/* <JMethod> */results = new HashSet/* <JMethod> */(); - Map/* <JClassType, Set<JMethod>> */overrideMap = getOrCreateMap( - virtualUpRefMap, method); - for (Iterator it = overrideMap.keySet().iterator(); it.hasNext();) { - JClassType classType = (JClassType) it.next(); + Set<JMethod> results = new HashSet<JMethod>(); + Map<JClassType, Set<JMethod>> overrideMap = getOrCreateMap(virtualUpRefMap, + method); + for (JClassType classType : overrideMap.keySet()) { if (instantiatedTypes.contains(classType)) { - Set/* <JMethod> */set = (Set) overrideMap.get(classType); + Set<JMethod> set = overrideMap.get(classType); results.addAll(set); } } - return (JMethod[]) results.toArray(new JMethod[results.size()]); + return results.toArray(new JMethod[results.size()]); } - public Set/* <JReferenceType> */getInstantiatedTypes() { + public Set<JReferenceType> getInstantiatedTypes() { return instantiatedTypes; } @@ -300,18 +298,17 @@ public void recomputeClinits() { hasClinitSet.clear(); for (int i = 0; i < program.getDeclaredTypes().size(); ++i) { - JReferenceType type = (JReferenceType) program.getDeclaredTypes().get(i); + JReferenceType type = program.getDeclaredTypes().get(i); computeHasClinit(type); } } - public void setInstantiatedTypes(Set/* <JReferenceType> */instantiatedTypes) { + public void setInstantiatedTypes(Set<JReferenceType> instantiatedTypes) { this.instantiatedTypes.clear(); this.instantiatedTypes.addAll(instantiatedTypes); } - private/* <K, V> */void add(Map/* <K, Set<V>> */map, Object key, - Object value) { + private <K, V> void add(Map<K, Set<V>> map, K key, V value) { getOrCreate(map, key).add(value); } @@ -320,31 +317,26 @@ * super types or sub types. */ private void computeCouldImplement(JClassType type) { - Set/* <JInterfaceType> */couldImplementSet = getOrCreate( - couldImplementMap, type); + Set<JInterfaceType> couldImplementSet = getOrCreate(couldImplementMap, type); // all of my direct implements are trivially true couldImplementSet.addAll(getOrCreate(implementsMap, type)); - List/* <JClassType> */subclasses = new ArrayList/* <JClassType> */(); + List<JClassType> subclasses = new ArrayList<JClassType>(); subclasses.addAll(getOrCreate(subClassMap, type)); - for (Iterator itSub = subclasses.iterator(); itSub.hasNext();) { - JClassType subclass = (JClassType) itSub.next(); - for (Iterator itIntf = subclass.implments.iterator(); itIntf.hasNext();) { - JInterfaceType intf = (JInterfaceType) itIntf.next(); + for (JClassType subclass : subclasses) { + for (JInterfaceType intf : subclass.implments) { couldImplementSet.add(intf); - for (Iterator itIsUp = getOrCreate(superInterfaceMap, intf).iterator(); itIsUp.hasNext();) { - JInterfaceType isup = (JInterfaceType) itIsUp.next(); + for (JInterfaceType isup : getOrCreate(superInterfaceMap, intf)) { couldImplementSet.add(isup); } } } - for (Iterator itCouldImpl = couldImplementSet.iterator(); itCouldImpl.hasNext();) { - JInterfaceType couldImpl = (JInterfaceType) itCouldImpl.next(); + for (JInterfaceType couldImpl : couldImplementSet) { add(couldBeImplementedMap, couldImpl, type); } } private void computeHasClinit(JReferenceType type) { - JMethod method = (JMethod) type.methods.get(0); + JMethod method = type.methods.get(0); JMethodBody body = (JMethodBody) method.getBody(); if (!body.getStatements().isEmpty()) { hasClinitSet.add(type); @@ -355,23 +347,19 @@ * Compute all of the things I implement directly, through super types. */ private void computeImplements(JClassType type) { - Set/* <JInterfaceType> */implementsSet = getOrCreate(implementsMap, type); - List/* <JClassType> */list = new ArrayList/* <JClassType> */(); + Set<JInterfaceType> implementsSet = getOrCreate(implementsMap, type); + List<JClassType> list = new ArrayList<JClassType>(); list.add(type); list.addAll(getOrCreate(superClassMap, type)); - for (Iterator itSuper = list.iterator(); itSuper.hasNext();) { - JClassType superclass = (JClassType) itSuper.next(); - for (Iterator itIntf = superclass.implments.iterator(); itIntf.hasNext();) { - JInterfaceType intf = (JInterfaceType) itIntf.next(); + for (JClassType superclass : list) { + for (JInterfaceType intf : superclass.implments) { implementsSet.add(intf); - for (Iterator itIsUp = getOrCreate(superInterfaceMap, intf).iterator(); itIsUp.hasNext();) { - JInterfaceType isup = (JInterfaceType) itIsUp.next(); + for (JInterfaceType isup : getOrCreate(superInterfaceMap, intf)) { implementsSet.add(isup); } } } - for (Iterator itImpl = implementsSet.iterator(); itImpl.hasNext();) { - JInterfaceType impl = (JInterfaceType) itImpl.next(); + for (JInterfaceType impl : implementsSet) { add(isImplementedMap, impl, type); } } @@ -393,13 +381,10 @@ * I define implementations for them. If I don't, then check all my super * classes to find virtual overrides. */ - for (Iterator itIntf = type.implments.iterator(); itIntf.hasNext();) { - JInterfaceType intf = (JInterfaceType) itIntf.next(); + for (JInterfaceType intf : type.implments) { computeVirtualUpRefs(type, intf); - Set/* <JInterfaceType> */superIntfs = getOrCreate(superInterfaceMap, - intf); - for (Iterator itSuper = superIntfs.iterator(); itSuper.hasNext();) { - JInterfaceType superIntf = (JInterfaceType) itSuper.next(); + Set<JInterfaceType> superIntfs = getOrCreate(superInterfaceMap, intf); + for (JInterfaceType superIntf : superIntfs) { computeVirtualUpRefs(type, superIntf); } } @@ -411,10 +396,8 @@ * classes to find virtual overrides. */ private void computeVirtualUpRefs(JClassType type, JInterfaceType intf) { - outer : for (Iterator itIntf = intf.methods.iterator(); itIntf.hasNext();) { - JMethod intfMethod = (JMethod) itIntf.next(); - for (Iterator itType = type.methods.iterator(); itType.hasNext();) { - JMethod classMethod = (JMethod) itType.next(); + outer : for (JMethod intfMethod : intf.methods) { + for (JMethod classMethod : type.methods) { if (JProgram.methodsDoMatch(intfMethod, classMethod)) { // this class directly implements the interface method continue outer; @@ -424,8 +407,7 @@ // this class does not directly implement the interface method // if any super classes do, create a virtual up ref for (JClassType superType = type.extnds; superType != javaLangObject; superType = superType.extnds) { - for (Iterator itSuper = superType.methods.iterator(); itSuper.hasNext();) { - JMethod superMethod = (JMethod) itSuper.next(); + for (JMethod superMethod : superType.methods) { if (JProgram.methodsDoMatch(intfMethod, superMethod)) { // this super class directly implements the interface method // create a virtual up ref @@ -434,9 +416,9 @@ // + "." + superMethod.getName() + " to " + intf.getName() + "." // + intfMethod.getName() + " via " + type.getName()); - Map/* <JClassType, Set<JMethod>> */classToMethodMap = getOrCreateMap( + Map<JClassType, Set<JMethod>> classToMethodMap = getOrCreateMap( virtualUpRefMap, superMethod); - Set/* <JMethod> */methodSet = getOrCreate(classToMethodMap, type); + Set<JMethod> methodSet = getOrCreate(classToMethodMap, type); methodSet.add(intfMethod); // do not search additional super types @@ -447,21 +429,19 @@ } } - private/* <K, V> */Set/* <V> */getOrCreate(Map/* <K, Set<V>> */map, - Object key) { - Set/* <V> */set = (Set) map.get(key); + private <K, V> Set<V> getOrCreate(Map<K, Set<V>> map, K key) { + Set<V> set = map.get(key); if (set == null) { - set = new HashSet/* <V> */(); + set = new HashSet<V>(); map.put(key, set); } return set; } - private/* <K, K2, V> */Map/* <K2, V> */getOrCreateMap( - Map/* <K, Map<K2, V>> */map, Object key) { - Map/* <K2, V> */map2 = (Map) map.get(key); + private <K, K2, V> Map<K2, V> getOrCreateMap(Map<K, Map<K2, V>> map, K key) { + Map<K2, V> map2 = map.get(key); if (map2 == null) { - map2 = new HashMap/* <K2, V> */(); + map2 = new HashMap<K2, V>(); map.put(key, map2); } return map2; @@ -471,7 +451,7 @@ * Record the all of my super classes (and myself as a subclass of them). */ private void recordSuperSubInfo(JClassType type) { - Set/* <JClassType> */superSet = getOrCreate(superClassMap, type); + Set<JClassType> superSet = getOrCreate(superClassMap, type); for (JClassType t = type.extnds; t != null; t = t.extnds) { superSet.add(t); add(subClassMap, t, type); @@ -483,7 +463,7 @@ * them). */ private void recordSuperSubInfo(JInterfaceType type) { - Set/* <JInterfaceType> */superSet = getOrCreate(superInterfaceMap, type); + Set<JInterfaceType> superSet = getOrCreate(superInterfaceMap, type); recordSuperSubInfo(type, superSet, type); } @@ -491,9 +471,8 @@ * Recursively record all of my super interfaces. */ private void recordSuperSubInfo(JInterfaceType base, - Set/* <JInterfaceType> */superSet, JInterfaceType cur) { - for (Iterator it = cur.implments.iterator(); it.hasNext();) { - JInterfaceType intf = (JInterfaceType) it.next(); + Set<JInterfaceType> superSet, JInterfaceType cur) { + for (JInterfaceType intf : cur.implments) { superSet.add(intf); add(subInterfaceMap, intf, base); recordSuperSubInfo(base, superSet, intf);