Add multiple security patches and improvements from IcedTea6 1.12.6.

http://mail.openjdk.java.net/pipermail/distro-pkg-dev/2013-July/023941.html

Obtained from:	IcedTea Project
PR:		ports/180541

1 files changed, 600 insertions, 0 deletions

diff --git a/java/openjdk6/files/icedtea/security/20130618/langtools_generics.patch b/java/openjdk6/files/icedtea/security/20130618/langtools_generics.patch
new file mode 100644
index 000000000000..7e59e30347c4
--- /dev/null
+++ b/java/openjdk6/files/icedtea/security/20130618/langtools_generics.patch
@@ -0,0 +1,600 @@
+# HG changeset patch
+# User andrew
+# Date 1371740021 18000
+# Node ID a5c99fd80b4c9f5049351bf5bff8517dd6d3b613
+# Parent  335cdc9887c56f560991275fe8d32e6edb6b3f1e
+Add generics
+
+diff --git a/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java b/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java
+--- langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java
++++ langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java
+@@ -41,29 +41,29 @@
+ public class ClassUseWriter extends SubWriterHolderWriter {
+ 
+     final ClassDoc classdoc;
+-    Set pkgToPackageAnnotations = null;
+-    final Map pkgToClassTypeParameter;
+-    final Map pkgToClassAnnotations;
+-    final Map pkgToMethodTypeParameter;
+-    final Map pkgToMethodArgTypeParameter;
+-    final Map pkgToMethodReturnTypeParameter;
+-    final Map pkgToMethodAnnotations;
+-    final Map pkgToMethodParameterAnnotations;
+-    final Map pkgToFieldTypeParameter;
+-    final Map pkgToFieldAnnotations;
+-    final Map pkgToSubclass;
+-    final Map pkgToSubinterface;
+-    final Map pkgToImplementingClass;
+-    final Map pkgToField;
+-    final Map pkgToMethodReturn;
+-    final Map pkgToMethodArgs;
+-    final Map pkgToMethodThrows;
+-    final Map pkgToConstructorAnnotations;
+-    final Map pkgToConstructorParameterAnnotations;
+-    final Map pkgToConstructorArgs;
+-    final Map pkgToConstructorArgTypeParameter;
+-    final Map pkgToConstructorThrows;
+-    final SortedSet pkgSet;
++    Set<PackageDoc> pkgToPackageAnnotations = null;
++    final Map<String,List<ProgramElementDoc>> pkgToClassTypeParameter;
++    final Map<String,List<ProgramElementDoc>> pkgToClassAnnotations;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodTypeParameter;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodArgTypeParameter;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodReturnTypeParameter;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodAnnotations;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodParameterAnnotations;
++    final Map<String,List<ProgramElementDoc>> pkgToFieldTypeParameter;
++    final Map<String,List<ProgramElementDoc>> pkgToFieldAnnotations;
++    final Map<String,List<ProgramElementDoc>> pkgToSubclass;
++    final Map<String,List<ProgramElementDoc>> pkgToSubinterface;
++    final Map<String,List<ProgramElementDoc>> pkgToImplementingClass;
++    final Map<String,List<ProgramElementDoc>> pkgToField;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodReturn;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodArgs;
++    final Map<String,List<ProgramElementDoc>> pkgToMethodThrows;
++    final Map<String,List<ProgramElementDoc>> pkgToConstructorAnnotations;
++    final Map<String,List<ProgramElementDoc>> pkgToConstructorParameterAnnotations;
++    final Map<String,List<ProgramElementDoc>> pkgToConstructorArgs;
++    final Map<String,List<ProgramElementDoc>> pkgToConstructorArgTypeParameter;
++    final Map<String,List<ProgramElementDoc>> pkgToConstructorThrows;
++    final SortedSet<PackageDoc> pkgSet;
+     final MethodWriterImpl methodSubWriter;
+     final ConstructorWriterImpl constrSubWriter;
+     final FieldWriterImpl fieldSubWriter;
+diff --git a/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java b/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java
+--- langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java
++++ langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageIndexWriter.java
+@@ -52,12 +52,12 @@
+      *
+      * @see Group
+      */
+-    private Map groupPackageMap;
++    private Map<String,List<PackageDoc>> groupPackageMap;
+ 
+     /**
+      * List to store the order groups as specified on the command line.
+      */
+-    private List groupList;
++    private List<String> groupList;
+ 
+     /**
+      * Construct the PackageIndexWriter. Also constructs the grouping
+@@ -103,8 +103,8 @@
+      */
+     protected void addIndex(Content body) {
+         for (int i = 0; i < groupList.size(); i++) {
+-        String groupname = (String)groupList.get(i);
+-        List list = (List)groupPackageMap.get(groupname);
++        String groupname = groupList.get(i);
++        List<PackageDoc> list = groupPackageMap.get(groupname);
+             if (list != null && list.size() > 0) {
+                 addIndexContents(list.toArray(new PackageDoc[list.size()]),
+                         groupname, configuration.getText("doclet.Member_Table_Summary",
+diff --git a/src/share/classes/com/sun/tools/doclets/formats/html/PackageUseWriter.java b/src/share/classes/com/sun/tools/doclets/formats/html/PackageUseWriter.java
+--- langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageUseWriter.java
++++ langtools/src/share/classes/com/sun/tools/doclets/formats/html/PackageUseWriter.java
+@@ -41,7 +41,7 @@
+ public class PackageUseWriter extends SubWriterHolderWriter {
+ 
+     final PackageDoc pkgdoc;
+-    final SortedMap usingPackageToUsedClasses = new TreeMap();
++    final SortedMap<String,Set<ClassDoc>> usingPackageToUsedClasses = new TreeMap<String,Set<ClassDoc>>();
+ 
+     /**
+      * Constructor.
+@@ -64,15 +64,15 @@
+         ClassDoc[] content = pkgdoc.allClasses();
+         for (int i = 0; i < content.length; ++i) {
+             ClassDoc usedClass = content[i];
+-            Set usingClasses = (Set)mapper.classToClass.get(usedClass.qualifiedName());
++            Set<ClassDoc> usingClasses = mapper.classToClass.get(usedClass.qualifiedName());
+             if (usingClasses != null) {
+-                for (Iterator it = usingClasses.iterator(); it.hasNext(); ) {
+-                    ClassDoc usingClass = (ClassDoc)it.next();
++                for (Iterator<ClassDoc> it = usingClasses.iterator(); it.hasNext(); ) {
++                    ClassDoc usingClass = it.next();
+                     PackageDoc usingPackage = usingClass.containingPackage();
+-                    Set usedClasses = (Set)usingPackageToUsedClasses
++                    Set<ClassDoc> usedClasses = (Set)usingPackageToUsedClasses
+                         .get(usingPackage.name());
+                     if (usedClasses == null) {
+-                        usedClasses = new TreeSet();
++                        usedClasses = new TreeSet<ClassDoc>();
+                         usingPackageToUsedClasses.put(Util.getPackageName(usingPackage),
+                                                       usedClasses);
+                     }
+@@ -153,9 +153,9 @@
+                 getPackageLinkString(pkgdoc, Util.getPackageName(pkgdoc), false))));
+         table.addContent(getSummaryTableHeader(packageTableHeader, "col"));
+         Content tbody = new HtmlTree(HtmlTag.TBODY);
+-        Iterator it = usingPackageToUsedClasses.keySet().iterator();
++        Iterator<String> it = usingPackageToUsedClasses.keySet().iterator();
+         for (int i = 0; it.hasNext(); i++) {
+-            PackageDoc pkg = configuration.root.packageNamed((String)it.next());
++            PackageDoc pkg = configuration.root.packageNamed(it.next());
+             HtmlTree tr = new HtmlTree(HtmlTag.TR);
+             if (i % 2 == 0) {
+                 tr.addStyle(HtmlStyle.altColor);
+@@ -181,9 +181,9 @@
+                     configuration.getText("doclet.Class"),
+                     configuration.getText("doclet.Description"))
+         };
+-        Iterator itp = usingPackageToUsedClasses.keySet().iterator();
++        Iterator<String> itp = usingPackageToUsedClasses.keySet().iterator();
+         while (itp.hasNext()) {
+-            String packageName = (String)itp.next();
++            String packageName = itp.next();
+             PackageDoc usingPackage = configuration.root.packageNamed(packageName);
+             HtmlTree li = new HtmlTree(HtmlTag.LI);
+             li.addStyle(HtmlStyle.blockList);
+@@ -199,9 +199,8 @@
+                     getPackageLinkString(usingPackage,Util.getPackageName(usingPackage), false))));
+             table.addContent(getSummaryTableHeader(classTableHeader, "col"));
+             Content tbody = new HtmlTree(HtmlTag.TBODY);
+-            Iterator itc =
+-                ((Collection)usingPackageToUsedClasses.get(packageName))
+-                .iterator();
++            Iterator<ClassDoc> itc =
++		usingPackageToUsedClasses.get(packageName).iterator();
+             for (int i = 0; itc.hasNext(); i++) {
+                 HtmlTree tr = new HtmlTree(HtmlTag.TR);
+                 if (i % 2 == 0) {
+diff --git a/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AbstractBuilder.java b/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AbstractBuilder.java
+--- langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AbstractBuilder.java
++++ langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/AbstractBuilder.java
+@@ -97,7 +97,7 @@
+      * @param node the XML element that specifies which component to document.
+      * @param contentTree content tree to which the documentation will be added
+      */
+-    protected void build(XMLNode node) {
++    protected void build(XMLNode node, Content contentTree) {
+         String component = node.name;
+         try {
+             invokeMethod("build" + component,
+diff --git a/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/LayoutParser.java b/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/LayoutParser.java
+--- langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/LayoutParser.java
++++ langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/LayoutParser.java
+@@ -80,7 +80,7 @@
+      */
+     public XMLNode parseXML(String root) {
+         if (xmlElementsMap.containsKey(root)) {
+-            return (List) xmlElementsMap.get(root);
++            return xmlElementsMap.get(root);
+         }
+         try {
+             currentRoot = root;
+diff --git a/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/SerializedFormBuilder.java b/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/SerializedFormBuilder.java
+--- langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/SerializedFormBuilder.java
++++ langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/builders/SerializedFormBuilder.java
+@@ -375,8 +375,7 @@
+      */
+     public void buildFieldSerializationOverview(ClassDoc classDoc, Content classContentTree) {
+         if (classDoc.definesSerializableFields()) {
+-            FieldDoc serialPersistentField =
+-                Util.asList(classDoc.serializableFields()).get(0);
++            FieldDoc serialPersistentField = classDoc.serializableFields()[0];
+             // Check to see if there are inline comments, tags or deprecation
+             // information to be printed.
+             if (fieldWriter.shouldPrintOverview(serialPersistentField)) {
+diff --git a/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassUseMapper.java b/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassUseMapper.java
+--- langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassUseMapper.java
++++ langtools/src/share/classes/com/sun/tools/doclets/internal/toolkit/util/ClassUseMapper.java
+@@ -46,150 +46,150 @@
+      * Mapping of ClassDocs to set of PackageDoc used by that class.
+      * Entries may be null.
+      */
+-    public Map classToPackage = new HashMap();
++    public Map<String,Set<PackageDoc>> classToPackage = new HashMap<String,Set<PackageDoc>>();
+ 
+     /**
+      * Mapping of Annotations to set of PackageDoc that use the annotation.
+      */
+-    public Map classToPackageAnnotations = new HashMap();
++    public Map<String,List<PackageDoc>> classToPackageAnnotations = new HashMap<String,List<PackageDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to set of ClassDoc used by that class.
+      * Entries may be null.
+      */
+-    public Map classToClass = new HashMap();
++    public Map<String,Set<ClassDoc>> classToClass = new HashMap<String,Set<ClassDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of ClassDoc which are direct or
+      * indirect subclasses of that class.
+      * Entries may be null.
+      */
+-    public Map classToSubclass = new HashMap();
++    public Map<String,List<ClassDoc>> classToSubclass = new HashMap<String,List<ClassDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of ClassDoc which are direct or
+      * indirect subinterfaces of that interface.
+      * Entries may be null.
+      */
+-    public Map classToSubinterface = new HashMap();
++    public Map<String,List<ClassDoc>> classToSubinterface = new HashMap<String,List<ClassDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of ClassDoc which implement
+      * this interface.
+      * Entries may be null.
+      */
+-    public Map classToImplementingClass = new HashMap();
++    public Map<String,List<ClassDoc>> classToImplementingClass = new HashMap<String,List<ClassDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of FieldDoc declared as that class.
+      * Entries may be null.
+      */
+-    public Map classToField = new HashMap();
++    public Map<String,List<FieldDoc>> classToField = new HashMap<String,List<FieldDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of MethodDoc returning that class.
+      * Entries may be null.
+      */
+-    public Map classToMethodReturn = new HashMap();
++    public Map<String,List<MethodDoc>> classToMethodReturn = new HashMap<String,List<MethodDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of MethodDoc having that class
+      * as an arg.
+      * Entries may be null.
+      */
+-    public Map classToMethodArgs = new HashMap();
++    public Map<String,List<ExecutableMemberDoc>> classToMethodArgs = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of MethodDoc which throws that class.
+      * Entries may be null.
+      */
+-    public Map classToMethodThrows = new HashMap();
++    public Map<String,List<ExecutableMemberDoc>> classToMethodThrows = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of ConstructorDoc having that class
+      * as an arg.
+      * Entries may be null.
+      */
+-    public Map classToConstructorArgs = new HashMap();
++    public Map<String,List<ExecutableMemberDoc>> classToConstructorArgs = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * Mapping of ClassDocs to list of ConstructorDoc which throws that class.
+      * Entries may be null.
+      */
+-    public Map classToConstructorThrows = new HashMap();
++    public Map<String,List<ExecutableMemberDoc>> classToConstructorThrows = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * The mapping of AnnotationTypeDocs to constructors that use them.
+      */
+-    public Map classToConstructorAnnotations = new HashMap();
+-
+-    /**
+-     * The mapping of AnnotationTypeDocs to Constructor parameters that use them.
+-     */
+-    public Map classToConstructorParamAnnotation = new HashMap();
++    public Map<String,List<ConstructorDoc>> classToConstructorAnnotations = new HashMap<String,List<ConstructorDoc>>();
++ 
++     /**
++      * The mapping of AnnotationTypeDocs to Constructor parameters that use them.
++      */
++    public Map<String,List<ExecutableMemberDoc>> classToConstructorParamAnnotation = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * The mapping of ClassDocs to Constructor arguments that use them as type parameters.
+      */
+-    public Map classToConstructorDocArgTypeParam = new HashMap();
++    public Map<String,List<ExecutableMemberDoc>> classToConstructorDocArgTypeParam = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * The mapping of ClassDocs to ClassDocs that use them as type parameters.
+      */
+-    public Map classToClassTypeParam = new HashMap();
++    public Map<String,List<ClassDoc>> classToClassTypeParam = new HashMap<String,List<ClassDoc>>();
+ 
+     /**
+      * The mapping of AnnotationTypeDocs to ClassDocs that use them.
+      */
+-    public Map classToClassAnnotations = new HashMap();
++    public Map<String,List<ClassDoc>> classToClassAnnotations = new HashMap<String,List<ClassDoc>>();
+ 
+     /**
+      * The mapping of ClassDocs to ExecutableMemberDocs that use them as type parameters.
+      */
+-    public Map classToExecMemberDocTypeParam = new HashMap();
++    public Map<String,List<MethodDoc>> classToExecMemberDocTypeParam = new HashMap<String,List<MethodDoc>>();
+ 
+     /**
+      * The mapping of ClassDocs to ExecutableMemberDocs arguments that use them as type parameters.
+      */
+-    public Map classToExecMemberDocArgTypeParam = new HashMap();
++    public Map<String,List<ExecutableMemberDoc>> classToExecMemberDocArgTypeParam = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * The mapping of AnnotationTypeDocs to ExecutableMemberDocs that use them.
+      */
+-    public Map classToExecMemberDocAnnotations = new HashMap();
++    public Map<String,List<MethodDoc>> classToExecMemberDocAnnotations = new HashMap<String,List<MethodDoc>>();
+ 
+     /**
+      * The mapping of ClassDocs to ExecutableMemberDocs that have return type
+      * with type parameters of that class.
+      */
+-    public Map classToExecMemberDocReturnTypeParam = new HashMap();
++    public Map<String,List<MethodDoc>> classToExecMemberDocReturnTypeParam = new HashMap<String,List<MethodDoc>>();
+ 
+     /**
+      * The mapping of AnnotationTypeDocs to MethodDoc parameters that use them.
+      */
+-    public Map classToExecMemberDocParamAnnotation = new HashMap();
++    public Map<String,List<ExecutableMemberDoc>> classToExecMemberDocParamAnnotation = new HashMap<String,List<ExecutableMemberDoc>>();
+ 
+     /**
+      * The mapping of ClassDocs to FieldDocs that use them as type parameters.
+      */
+-    public Map classToFieldDocTypeParam = new HashMap();
++    public Map<String,List<FieldDoc>> classToFieldDocTypeParam = new HashMap<String,List<FieldDoc>>();
+ 
+     /**
+      * The mapping of AnnotationTypeDocs to FieldDocs that use them.
+      */
+-    public Map annotationToFieldDoc = new HashMap();
++    public Map<String,List<FieldDoc>> annotationToFieldDoc = new HashMap<String,List<FieldDoc>>();
+ 
+ 
+     public ClassUseMapper(RootDoc root, ClassTree classtree) {
+         this.classtree = classtree;
+ 
+         // Map subclassing, subinterfacing implementing, ...
+-        for (Iterator it = classtree.baseclasses().iterator(); it.hasNext();) {
+-            subclasses((ClassDoc)it.next());
++        for (Iterator<ClassDoc> it = classtree.baseclasses().iterator(); it.hasNext();) {
++            subclasses(it.next());
+         }
+-        for (Iterator it = classtree.baseinterfaces().iterator(); it.hasNext();) {
++        for (Iterator<ClassDoc> it = classtree.baseinterfaces().iterator(); it.hasNext();) {
+             // does subinterfacing as side-effect
+-            implementingClasses((ClassDoc)it.next());
++            implementingClasses(it.next());
+         }
+         // Map methods, fields, constructors using a class.
+         ClassDoc[] classes = root.classes();
+@@ -231,15 +231,15 @@
+     /**
+      * Return all subclasses of a class AND fill-in classToSubclass map.
+      */
+-    private Collection subclasses(ClassDoc cd) {
+-        Collection ret = (Collection)classToSubclass.get(cd.qualifiedName());
++    private Collection<ClassDoc> subclasses(ClassDoc cd) {
++        Collection<ClassDoc> ret = classToSubclass.get(cd.qualifiedName());
+         if (ret == null) {
+-            ret = new TreeSet();
+-            List subs = classtree.subclasses(cd);
++            ret = new TreeSet<ClassDoc>();
++            List<ClassDoc> subs = classtree.subclasses(cd);
+             if (subs != null) {
+                 ret.addAll(subs);
+-                for (Iterator it = subs.iterator(); it.hasNext();) {
+-                    ret.addAll(subclasses((ClassDoc)it.next()));
++                for (Iterator<ClassDoc> it = subs.iterator(); it.hasNext();) {
++                    ret.addAll(subclasses(it.next()));
+                 }
+             }
+             addAll(classToSubclass, cd, ret);
+@@ -250,15 +250,15 @@
+     /**
+      * Return all subinterfaces of an interface AND fill-in classToSubinterface map.
+      */
+-    private Collection subinterfaces(ClassDoc cd) {
+-        Collection ret = (Collection)classToSubinterface.get(cd.qualifiedName());
++    private Collection<ClassDoc> subinterfaces(ClassDoc cd) {
++        Collection<ClassDoc> ret = classToSubinterface.get(cd.qualifiedName());
+         if (ret == null) {
+-            ret = new TreeSet();
+-            List subs = classtree.subinterfaces(cd);
++            ret = new TreeSet<ClassDoc>();
++            List<ClassDoc> subs = classtree.subinterfaces(cd);
+             if (subs != null) {
+                 ret.addAll(subs);
+-                for (Iterator it = subs.iterator(); it.hasNext();) {
+-                    ret.addAll(subinterfaces((ClassDoc)it.next()));
++                for (Iterator<ClassDoc> it = subs.iterator(); it.hasNext();) {
++                    ret.addAll(subinterfaces(it.next()));
+                 }
+             }
+             addAll(classToSubinterface, cd, ret);
+@@ -272,19 +272,19 @@
+      * implementing subinterfaces) AND fill-in both classToImplementingClass
+      * and classToSubinterface maps.
+      */
+-    private Collection implementingClasses(ClassDoc cd) {
+-        Collection ret = (List)classToImplementingClass.get(cd.qualifiedName());
++    private Collection<ClassDoc> implementingClasses(ClassDoc cd) {
++        Collection<ClassDoc> ret = classToImplementingClass.get(cd.qualifiedName());
+         if (ret == null) {
+-            ret = new TreeSet();
+-            List impl = classtree.implementingclasses(cd);
++            ret = new TreeSet<ClassDoc>();
++            List<ClassDoc> impl = classtree.implementingclasses(cd);
+             if (impl != null) {
+                 ret.addAll(impl);
+-                for (Iterator it = impl.iterator(); it.hasNext();) {
+-                    ret.addAll(subclasses((ClassDoc)it.next()));
++                for (Iterator<ClassDoc> it = impl.iterator(); it.hasNext();) {
++                    ret.addAll(subclasses(it.next()));
+                 }
+             }
+-            for (Iterator it = subinterfaces(cd).iterator(); it.hasNext();) {
+-                ret.addAll(implementingClasses((ClassDoc)it.next()));
++            for (Iterator<ClassDoc> it = subinterfaces(cd).iterator(); it.hasNext();) {
++                ret.addAll(implementingClasses(it.next()));
+             }
+             addAll(classToImplementingClass, cd, ret);
+         }
+@@ -298,7 +298,7 @@
+     private void mapExecutable(ExecutableMemberDoc em) {
+         Parameter[] params = em.parameters();
+         boolean isConstructor = em.isConstructor();
+-        List classArgs = new ArrayList();
++        List<Type> classArgs = new ArrayList();
+         for (int k = 0; k < params.length; k++) {
+             Type pcd = params[k].type();
+             // primitives don't get mapped, also avoid dups
+@@ -325,34 +325,36 @@
+         }
+     }
+ 
+-    private List refList(Map map, ClassDoc cd) {
+-        List list = (List)map.get(cd.qualifiedName());
++    private <T> List<T> refList(Map<String,List<T>> map, ClassDoc cd) {
++        List<T> list = map.get(cd.qualifiedName());
+         if (list == null) {
+-            list = new ArrayList();
++            List<T> l = new ArrayList<T>();
++            list = l;
+             map.put(cd.qualifiedName(), list);
+         }
+         return list;
+     }
+ 
+-    private Set packageSet(ClassDoc cd) {
+-        Set pkgSet = (Set)classToPackage.get(cd.qualifiedName());
++    private Set<PackageDoc> packageSet(ClassDoc cd) {
++        Set<PackageDoc> pkgSet = classToPackage.get(cd.qualifiedName());
+         if (pkgSet == null) {
+-            pkgSet = new TreeSet();
++            pkgSet = new TreeSet<PackageDoc>();
+             classToPackage.put(cd.qualifiedName(), pkgSet);
+         }
+         return pkgSet;
+     }
+ 
+-    private Set classSet(ClassDoc cd) {
+-        Set clsSet = (Set)classToClass.get(cd.qualifiedName());
++    private Set<ClassDoc> classSet(ClassDoc cd) {
++        Set<ClassDoc> clsSet = classToClass.get(cd.qualifiedName());
+         if (clsSet == null) {
+-            clsSet = new TreeSet();
++            Set<ClassDoc> s = new TreeSet<ClassDoc>();
++            clsSet = s;
+             classToClass.put(cd.qualifiedName(), clsSet);
+         }
+         return clsSet;
+     }
+ 
+-    private void add(Map map, ClassDoc cd, ProgramElementDoc ref) {
++    private <T extends ProgramElementDoc> void add(Map<String,List<T>> map, ClassDoc cd, T ref) {
+         // add to specified map
+         refList(map, cd).add(ref);
+ 
+@@ -361,7 +363,7 @@
+ 
+         classSet(cd).add(ref instanceof MemberDoc?
+                 ((MemberDoc)ref).containingClass() :
+-                    ref);
++                    (ClassDoc)ref);
+     }
+ 
+     private void addAll(Map map, ClassDoc cd, Collection refs) {
+@@ -371,15 +373,13 @@
+         // add to specified map
+         refList(map, cd).addAll(refs);
+ 
+-        Set pkgSet = packageSet(cd);
+-        Set clsSet = classSet(cd);
++        Set<PackageDoc> pkgSet = packageSet(cd);
++        Set<ClassDoc> clsSet = classSet(cd);
+         // add ref's package to package map and class map
+-        for (Iterator it = refs.iterator(); it.hasNext();) {
+-            ProgramElementDoc pedoc = (ProgramElementDoc)it.next();
+-            pkgSet.add(pedoc.containingPackage());
+-            clsSet.add(pedoc instanceof MemberDoc?
+-                    ((MemberDoc)pedoc).containingClass() :
+-                        pedoc);
++        for (Iterator<ClassDoc> it = refs.iterator(); it.hasNext();) {
++	    ClassDoc cls = it.next();
++            pkgSet.add(cls.containingPackage());
++            clsSet.add(cls);
+ 
+         }
+     }
+@@ -392,8 +392,8 @@
+      * @param doc the doc whose type parameters are being checked.
+      * @param holder the holder that owns the type parameters.
+      */
+-    private void mapTypeParameters(Map map, Object doc,
+-            ProgramElementDoc holder) {
++    private <T extends ProgramElementDoc> void mapTypeParameters(Map<String,List<T>> map, Object doc,
++            T holder) {
+         TypeVariable[] typeVariables;
+         if (doc instanceof ClassDoc) {
+             typeVariables = ((ClassDoc) doc).typeParameters();
+@@ -438,8 +438,8 @@
+      * @param doc the doc whose type parameters are being checked.
+      * @param holder the holder that owns the type parameters.
+      */
+-    private void mapAnnotations(Map map, Object doc,
+-            Object holder) {
++    private <T extends ProgramElementDoc> void mapAnnotations(Map<String,List<T>> map, Object doc,
++            T holder) {
+         TypeVariable[] typeVariables;
+         AnnotationDesc[] annotations;
+         boolean isPackage = false;
+@@ -458,12 +458,31 @@
+             if (isPackage)
+                 refList(map, annotationDoc).add(holder);
+             else
+-                add(map, annotationDoc, (ProgramElementDoc) holder);
++                add(map, annotationDoc, holder);
+         }
+     }
+ 
+-    private void addTypeParameterToMap(Map map, Type type,
+-            ProgramElementDoc holder) {
++
++    /**
++     * Map the AnnotationType to the ProgramElementDocs that use them as
++     * type parameters.
++     *
++     * @param map the map the insert the information into.
++     * @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;
++        annotations = doc.annotations();
++        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,
++            T holder) {
+         if (type instanceof ClassDoc) {
+             add(map, (ClassDoc) type, holder);
+         } else if (type instanceof ParameterizedType) {