jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassUseMapper.java

equal deleted inserted replaced

-:dca1b80ed62c
+:682da512ec17
 public ClassUseMapper(RootDoc root, ClassTree classtree) {
 this.classtree = classtree;
 // Map subclassing, subinterfacing implementing, ...
-for (Iterator<ClassDoc> it = classtree.baseclasses().iterator(); it.hasNext();) {
+for (ClassDoc doc : classtree.baseclasses()) {
-subclasses(it.next());
+subclasses(doc);
 }
-for (Iterator<ClassDoc> it = classtree.baseinterfaces().iterator(); it.hasNext();) {
+for (ClassDoc doc : classtree.baseinterfaces()) {
 // does subinterfacing as side-effect
-implementingClasses(it.next());
+implementingClasses(doc);
 }
 // Map methods, fields, constructors using a class.
 ClassDoc[] classes = root.classes();
-for (int i = 0; i < classes.length; i++) {
+for (ClassDoc aClass : classes) {
-PackageDoc pkg = classes[i].containingPackage();
+PackageDoc pkg = aClass.containingPackage();
 mapAnnotations(classToPackageAnnotations, pkg, pkg);
-ClassDoc cd = classes[i];
+ClassDoc cd = aClass;
 mapTypeParameters(classToClassTypeParam, cd, cd);
 mapAnnotations(classToClassAnnotations, cd, cd);
 FieldDoc[] fields = cd.fields();
-for (int j = 0; j < fields.length; j++) {
+for (FieldDoc fd : fields) {
-FieldDoc fd = fields[j];
 mapTypeParameters(classToFieldDocTypeParam, fd, fd);
 mapAnnotations(annotationToFieldDoc, fd, fd);
-if (! fd.type().isPrimitive()) {
+if (!fd.type().isPrimitive()) {
 add(classToField, fd.type().asClassDoc(), fd);
 }
 }
 ConstructorDoc[] cons = cd.constructors();
-for (int j = 0; j < cons.length; j++) {
+for (ConstructorDoc con : cons) {
-mapAnnotations(classToConstructorAnnotations, cons[j], cons[j]);
+mapAnnotations(classToConstructorAnnotations, con, con);
-mapExecutable(cons[j]);
+mapExecutable(con);
 }
 MethodDoc[] meths = cd.methods();
-for (int j = 0; j < meths.length; j++) {
+for (MethodDoc md : meths) {
-MethodDoc md = meths[j];
 mapExecutable(md);
 mapTypeParameters(classToExecMemberDocTypeParam, md, md);
 mapAnnotations(classToExecMemberDocAnnotations, md, md);
-if (! (md.returnType().isPrimitive() || md.returnType() instanceof TypeVariable)) {
+if (!(md.returnType().isPrimitive() || md.returnType() instanceof TypeVariable)) {
 mapTypeParameters(classToExecMemberDocReturnTypeParam,
 md.returnType(), md);
 add(classToMethodReturn, md.returnType().asClassDoc(), md);
 }
 }
 }
 }
 if (ret == null) {
 ret = new TreeSet<ClassDoc>();
 List<ClassDoc> subs = classtree.subclasses(cd);
 if (subs != null) {
 ret.addAll(subs);
-for (Iterator<ClassDoc> it = subs.iterator(); it.hasNext();) {
+for (ClassDoc sub : subs) {
-ret.addAll(subclasses(it.next()));
+ret.addAll(subclasses(sub));
 }
 }
 addAll(classToSubclass, cd, ret);
 }
 return ret;
 if (ret == null) {
 ret = new TreeSet<ClassDoc>();
 List<ClassDoc> subs = classtree.subinterfaces(cd);
 if (subs != null) {
 ret.addAll(subs);
-for (Iterator<ClassDoc> it = subs.iterator(); it.hasNext();) {
+for (ClassDoc sub : subs) {
-ret.addAll(subinterfaces(it.next()));
+ret.addAll(subinterfaces(sub));
 }
 }
 addAll(classToSubinterface, cd, ret);
 }
 return ret;
 if (ret == null) {
 ret = new TreeSet<ClassDoc>();
 List<ClassDoc> impl = classtree.implementingclasses(cd);
 if (impl != null) {
 ret.addAll(impl);
-for (Iterator<ClassDoc> it = impl.iterator(); it.hasNext();) {
+for (ClassDoc anImpl : impl) {
-ret.addAll(subclasses(it.next()));
+ret.addAll(subclasses(anImpl));
 }
 }
-for (Iterator<ClassDoc> it = subinterfaces(cd).iterator(); it.hasNext();) {
+for (ClassDoc doc : subinterfaces(cd)) {
-ret.addAll(implementingClasses(it.next()));
+ret.addAll(implementingClasses(doc));
 }
 addAll(classToImplementingClass, cd, ret);
 }
 return ret;
 }
 /**
 * Determine classes used by a method or constructor, so they can be
 * inverse mapped.
 */
 private void mapExecutable(ExecutableMemberDoc em) {
-Parameter[] params = em.parameters();
 boolean isConstructor = em.isConstructor();
 List<Type> classArgs = new ArrayList<Type>();
-for (int k = 0; k < params.length; k++) {
+for (Parameter param : em.parameters()) {
-Type pcd = params[k].type();
+Type pcd = param.type();
 // primitives don't get mapped, also avoid dups
-if ((! params[k].type().isPrimitive()) &&
+if ((!param.type().isPrimitive()) &&
-! classArgs.contains(pcd) &&
+!classArgs.contains(pcd) &&
-! (pcd instanceof TypeVariable)) {
+!(pcd instanceof TypeVariable)) {
-add(isConstructor? classToConstructorArgs :classToMethodArgs,
+add(isConstructor ? classToConstructorArgs : classToMethodArgs,
 pcd.asClassDoc(), em);
 classArgs.add(pcd);
-mapTypeParameters(isConstructor?
+mapTypeParameters(isConstructor ?
 classToConstructorDocArgTypeParam : classToExecMemberDocArgTypeParam,
 pcd, em);
 }
 mapAnnotations(
 isConstructor ?
 classToConstructorParamAnnotation :
 classToExecMemberDocParamAnnotation,
-params[k], em);
+param, em);
 }
-ClassDoc[] thr = em.thrownExceptions();
+for (ClassDoc anException : em.thrownExceptions()) {
-for (int k = 0; k < thr.length; k++) {
+add(isConstructor ? classToConstructorThrows : classToMethodThrows,
-add(isConstructor? classToConstructorThrows : classToMethodThrows,
+anException, em);
-thr[k], em);
 }
 }
 private <T> List<T> refList(Map<String,List<T>> map, ClassDoc cd) {
 List<T> list = map.get(cd.qualifiedName());
 refList(map, cd).addAll(refs);
 Set<PackageDoc> pkgSet = packageSet(cd);
 Set<ClassDoc> clsSet = classSet(cd);
 // add ref's package to package map and class map
-for (Iterator<ClassDoc> it = refs.iterator(); it.hasNext();) {
+for (ClassDoc cls : refs) {
-ClassDoc cls = it.next();
 pkgSet.add(cls.containingPackage());
 clsSet.add(cls);
 }
 }
 T holder) {
 TypeVariable[] typeVariables;
 if (doc instanceof ClassDoc) {
 typeVariables = ((ClassDoc) doc).typeParameters();
 } else if (doc instanceof WildcardType) {
-Type[] extendsBounds = ((WildcardType) doc).extendsBounds();
+for (Type extendsBound : ((WildcardType) doc).extendsBounds()) {
-for (int k = 0; k < extendsBounds.length; k++) {
+addTypeParameterToMap(map, extendsBound, holder);
-addTypeParameterToMap(map, extendsBounds[k], holder);
+}
-}
+for (Type superBound : ((WildcardType) doc).superBounds()) {
-Type[] superBounds = ((WildcardType) doc).superBounds();
+addTypeParameterToMap(map, superBound, holder);
-for (int k = 0; k < superBounds.length; k++) {
-addTypeParameterToMap(map, superBounds[k], holder);
 }
 return;
 } else if (doc instanceof ParameterizedType) {
-Type[] typeArguments = ((ParameterizedType) doc).typeArguments();
+for (Type typeArgument : ((ParameterizedType) doc).typeArguments()) {
-for (int k = 0; k < typeArguments.length; k++) {
+addTypeParameterToMap(map, typeArgument, holder);
-addTypeParameterToMap(map, typeArguments[k], holder);
 }
 return;
 } else if (doc instanceof ExecutableMemberDoc) {
 typeVariables = ((ExecutableMemberDoc) doc).typeParameters();
 } else if (doc instanceof FieldDoc) {
 mapTypeParameters(map, fieldType, holder);
 return;
 } else {
 return;
 }
-for (int i = 0; i < typeVariables.length; i++) {
+for (TypeVariable typeVariable : typeVariables) {
-Type[] bounds = typeVariables[i].bounds();
+for (Type bound : typeVariable.bounds()) {
-for (int j = 0; j < bounds.length; j++) {
+addTypeParameterToMap(map, bound, holder);
-addTypeParameterToMap(map, bounds[j], holder);
 }
 }
 }
 /**
 } else if (doc instanceof Parameter) {
 annotations = ((Parameter) doc).annotations();
 } else {
 throw new DocletAbortException("should not happen");
 }
-for (int i = 0; i < annotations.length; i++) {
+for (AnnotationDesc annotation : annotations) {
-AnnotationTypeDoc annotationDoc = annotations[i].annotationType();
+AnnotationTypeDoc annotationDoc = annotation.annotationType();
 if (isPackage)
 refList(map, annotationDoc).add(holder);
 else
 add(map, annotationDoc, holder);
 }
 * @param doc the doc whose type parameters are being checked.
 * @param holder the holder that owns the type parameters.
 */
 private <T extends PackageDoc> void mapAnnotations(Map<String,List<T>> map, PackageDoc doc,
 T holder) {
-AnnotationDesc[] annotations;
+for (AnnotationDesc annotation : doc.annotations()) {
-annotations = doc.annotations();
+AnnotationTypeDoc annotationDoc = annotation.annotationType();
-for (int i = 0; i < annotations.length; i++) {
-AnnotationTypeDoc annotationDoc = annotations[i].annotationType();
 refList(map, annotationDoc).add(holder);
 }
 }
 private <T extends ProgramElementDoc> void addTypeParameterToMap(Map<String,List<T>> map, Type type,

changeset 22159	682da512ec17
parent 19667	fdfce85627a9
child 22163	3651128c74eb