changeset 453:361a1941d599

Merge from main OpenJDK repository
author glewis@misty.eyesbeyond.com
date Sat, 31 Oct 2009 08:52:31 -0700
parents 969a6b754a14 c8083dc525b6
children f2450a4993b7
files
diffstat 25 files changed, 1910 insertions(+), 182 deletions(-) [+]
line wrap: on
line diff
--- a/.hgtags	Sun Oct 18 15:10:48 2009 -0700
+++ b/.hgtags	Sat Oct 31 08:52:31 2009 -0700
@@ -49,3 +49,4 @@
 261c54b2312ed26d6ec45c675831375460250519 jdk7-b72
 9596dff460935f09684c11d156ce591f92584f0d jdk7-b73
 1a66b08deed0459054b5b1bea3dfbead30d258fa jdk7-b74
+2485f5641ed0829205aaaeb31ad711c2c2ef0de3 jdk7-b75
--- a/src/share/classes/com/sun/tools/classfile/ConstantPool.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/classfile/ConstantPool.java	Sat Oct 31 08:52:31 2009 -0700
@@ -369,14 +369,33 @@
             return 3;
         }
 
+        /**
+         * Get the raw value of the class referenced by this constant pool entry.
+         * This will either be the name of the class, in internal form, or a
+         * descriptor for an array class.
+         * @return the raw value of the class
+         */
         public String getName() throws ConstantPoolException {
             return cp.getUTF8Value(name_index);
         }
 
+        /**
+         * If this constant pool entry identifies either a class or interface type,
+         * or a possibly multi-dimensional array of a class of interface type,
+         * return the name of the class or interface in internal form. Otherwise,
+         * (i.e. if this is a possibly multi-dimensional array of a primitive type),
+         * return null.
+         * @return the base class or interface name
+         */
         public String getBaseName() throws ConstantPoolException {
             String name = getName();
-            int index = name.indexOf("[L") + 1;
-            return name.substring(index);
+            if (name.startsWith("[")) {
+                int index = name.indexOf("[L");
+                if (index == -1)
+                    return null;
+                return name.substring(index + 2, name.length() - 1);
+            } else
+                return name;
         }
 
         public int getDimensionCount() throws ConstantPoolException {
--- a/src/share/classes/com/sun/tools/classfile/Signature.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/classfile/Signature.java	Sat Oct 31 08:52:31 2009 -0700
@@ -27,6 +27,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import com.sun.tools.classfile.Type.*;
 
 /**
  * See JVMS3 4.4.4.
@@ -50,19 +51,19 @@
 
     @Override
     public int getParameterCount(ConstantPool constant_pool) throws ConstantPoolException {
-        Type.MethodType m = (Type.MethodType) getType(constant_pool);
-        return m.argTypes.size();
+        MethodType m = (MethodType) getType(constant_pool);
+        return m.paramTypes.size();
     }
 
     @Override
     public String getParameterTypes(ConstantPool constant_pool) throws ConstantPoolException {
-        Type.MethodType m = (Type.MethodType) getType(constant_pool);
+        MethodType m = (MethodType) getType(constant_pool);
         StringBuilder sb = new StringBuilder();
         sb.append("(");
         String sep = "";
-        for (Type argType: m.argTypes) {
+        for (Type paramType: m.paramTypes) {
             sb.append(sep);
-            sb.append(argType);
+            sb.append(paramType);
             sep = ", ";
         }
         sb.append(")");
@@ -71,7 +72,7 @@
 
     @Override
     public String getReturnType(ConstantPool constant_pool) throws ConstantPoolException {
-        Type.MethodType m = (Type.MethodType) getType(constant_pool);
+        MethodType m = (MethodType) getType(constant_pool);
         return m.returnType.toString();
     }
 
@@ -84,12 +85,12 @@
         this.sig = sig;
         sigp = 0;
 
-        List<Type> typeArgTypes = null;
+        List<TypeParamType> typeParamTypes = null;
         if (sig.charAt(sigp) == '<')
-            typeArgTypes = parseTypeArgTypes();
+            typeParamTypes = parseTypeParamTypes();
 
         if (sig.charAt(sigp) == '(') {
-            List<Type> argTypes = parseTypeSignatures(')');
+            List<Type> paramTypes = parseTypeSignatures(')');
             Type returnType = parseTypeSignature();
             List<Type> throwsTypes = null;
             while (sigp < sig.length() && sig.charAt(sigp) == '^') {
@@ -98,16 +99,19 @@
                     throwsTypes = new ArrayList<Type>();
                 throwsTypes.add(parseTypeSignature());
             }
-            return new Type.MethodType(typeArgTypes, argTypes, returnType, throwsTypes);
+            return new MethodType(typeParamTypes, paramTypes, returnType, throwsTypes);
         } else {
             Type t = parseTypeSignature();
-            if (typeArgTypes == null && sigp == sig.length())
+            if (typeParamTypes == null && sigp == sig.length())
                 return t;
             Type superclass = t;
-            List<Type> superinterfaces = new ArrayList<Type>();
-            while (sigp < sig.length())
+            List<Type> superinterfaces = null;
+            while (sigp < sig.length()) {
+                if (superinterfaces == null)
+                    superinterfaces = new ArrayList<Type>();
                 superinterfaces.add(parseTypeSignature());
-            return new Type.ClassSigType(typeArgTypes, superclass, superinterfaces);
+            }
+            return new ClassSigType(typeParamTypes, superclass, superinterfaces);
 
         }
     }
@@ -116,61 +120,61 @@
         switch (sig.charAt(sigp)) {
             case 'B':
                 sigp++;
-                return new Type.SimpleType("byte");
+                return new SimpleType("byte");
 
             case 'C':
                 sigp++;
-                return new Type.SimpleType("char");
+                return new SimpleType("char");
 
             case 'D':
                 sigp++;
-                return new Type.SimpleType("double");
+                return new SimpleType("double");
 
             case 'F':
                 sigp++;
-                return new Type.SimpleType("float");
+                return new SimpleType("float");
 
             case 'I':
                 sigp++;
-                return new Type.SimpleType("int");
+                return new SimpleType("int");
 
             case 'J':
                 sigp++;
-                return new Type.SimpleType("long");
+                return new SimpleType("long");
 
             case 'L':
                 return parseClassTypeSignature();
 
             case 'S':
                 sigp++;
-                return new Type.SimpleType("short");
+                return new SimpleType("short");
 
             case 'T':
                 return parseTypeVariableSignature();
 
             case 'V':
                 sigp++;
-                return new Type.SimpleType("void");
+                return new SimpleType("void");
 
             case 'Z':
                 sigp++;
-                return new Type.SimpleType("boolean");
+                return new SimpleType("boolean");
 
             case '[':
                 sigp++;
-                return new Type.ArrayType(parseTypeSignature());
+                return new ArrayType(parseTypeSignature());
 
             case '*':
                 sigp++;
-                return new Type.WildcardType();
+                return new WildcardType();
 
             case '+':
                 sigp++;
-                return new Type.WildcardType("extends", parseTypeSignature());
+                return new WildcardType(WildcardType.Kind.EXTENDS, parseTypeSignature());
 
             case '-':
                 sigp++;
-                return new Type.WildcardType("super", parseTypeSignature());
+                return new WildcardType(WildcardType.Kind.SUPER, parseTypeSignature());
 
             default:
                 throw new IllegalStateException(debugInfo());
@@ -194,30 +198,22 @@
 
     private Type parseClassTypeSignatureRest() {
         StringBuilder sb = new StringBuilder();
-        Type t = null;
-        char sigch;
-        while (true) {
+        List<Type> argTypes = null;
+        ClassType t = null;
+        char sigch ;
+
+        do {
             switch  (sigch = sig.charAt(sigp)) {
-                case '/':
-                    sigp++;
-                    sb.append(".");
+                case '<':
+                    argTypes = parseTypeSignatures('>');
                     break;
 
                 case '.':
-                    sigp++;
-                    if (t == null)
-                        t = new Type.SimpleType(sb.toString());
-                    return new Type.InnerClassType(t, parseClassTypeSignatureRest());
-
                 case ';':
                     sigp++;
-                    if (t == null)
-                        t = new Type.SimpleType(sb.toString());
-                    return t;
-
-                case '<':
-                    List<Type> argTypes = parseTypeSignatures('>');
-                    t = new Type.ClassType(sb.toString(), argTypes);
+                    t = new ClassType(t, sb.toString(), argTypes);
+                    sb.setLength(0);
+                    argTypes = null;
                     break;
 
                 default:
@@ -225,21 +221,22 @@
                     sb.append(sigch);
                     break;
             }
-        }
+        } while (sigch != ';');
+
+        return t;
     }
 
-    private List<Type> parseTypeArgTypes() {
+    private List<TypeParamType> parseTypeParamTypes() {
         assert sig.charAt(sigp) == '<';
         sigp++;
-        List<Type> types = null;
-        types = new ArrayList<Type>();
+        List<TypeParamType> types = new ArrayList<TypeParamType>();
         while (sig.charAt(sigp) != '>')
-            types.add(parseTypeArgType());
+            types.add(parseTypeParamType());
         sigp++;
         return types;
     }
 
-    private Type parseTypeArgType() {
+    private TypeParamType parseTypeParamType() {
         int sep = sig.indexOf(":", sigp);
         String name = sig.substring(sigp, sep);
         Type classBound = null;
@@ -253,13 +250,13 @@
                 interfaceBounds = new ArrayList<Type>();
             interfaceBounds.add(parseTypeSignature());
         }
-        return new Type.TypeArgType(name, classBound, interfaceBounds);
+        return new TypeParamType(name, classBound, interfaceBounds);
     }
 
     private Type parseTypeVariableSignature() {
         sigp++;
         int sep = sig.indexOf(';', sigp);
-        Type t = new Type.SimpleType(sig.substring(sigp, sep));
+        Type t = new SimpleType(sig.substring(sigp, sep));
         sigp = sep + 1;
         return t;
     }
--- a/src/share/classes/com/sun/tools/classfile/Type.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/classfile/Type.java	Sat Oct 31 08:52:31 2009 -0700
@@ -31,6 +31,9 @@
 import java.util.Set;
 
 /*
+ *  Family of classes used to represent the parsed form of a {@link Descriptor}
+ *  or {@link Signature}.
+ *
  *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
  *  you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
@@ -62,11 +65,26 @@
         R visitMethodType(MethodType type, P p);
         R visitClassSigType(ClassSigType type, P p);
         R visitClassType(ClassType type, P p);
-        R visitInnerClassType(InnerClassType type, P p);
-        R visitTypeArgType(TypeArgType type, P p);
+        R visitTypeParamType(TypeParamType type, P p);
         R visitWildcardType(WildcardType type, P p);
     }
 
+    /**
+     * Represents a type signature with a simple name. The name may be that of a
+     * primitive type, such "{@code int}, {@code float}, etc
+     * or that of a type argument, such as {@code T}, {@code K}, {@code V}, etc.
+     *
+     * See:
+     * JVMS 4.3.2
+     *      BaseType:
+     *          {@code B}, {@code C}, {@code D}, {@code F}, {@code I},
+     *          {@code J}, {@code S}, {@code Z};
+     *      VoidDescriptor:
+     *          {@code V};
+     * JVMS 4.3.4
+     *      TypeVariableSignature:
+     *          {@code T} Identifier {@code ;}
+     */
     public static class SimpleType extends Type {
         public SimpleType(String name) {
             this.name = name;
@@ -91,6 +109,14 @@
         public final String name;
     }
 
+    /**
+     * Represents an array type signature.
+     *
+     * See:
+     * JVMS 4.3.4
+     *      ArrayTypeSignature:
+     *          {@code [} TypeSignature {@code ]}
+     */
     public static class ArrayType extends Type {
         public ArrayType(Type elemType) {
             this.elemType = elemType;
@@ -108,17 +134,26 @@
         public final Type elemType;
     }
 
+    /**
+     * Represents a method type signature.
+     *
+     * See;
+     * JVMS 4.3.4
+     *      MethodTypeSignature:
+     *          FormalTypeParameters_opt {@code (} TypeSignature* {@code)} ReturnType
+     *              ThrowsSignature*
+     */
     public static class MethodType extends Type {
-        public MethodType(List<? extends Type> argTypes, Type resultType) {
-            this(null, argTypes, resultType, null);
+        public MethodType(List<? extends Type> paramTypes, Type resultType) {
+            this(null, paramTypes, resultType, null);
         }
 
-        public MethodType(List<? extends Type> typeArgTypes,
-                List<? extends Type> argTypes,
+        public MethodType(List<? extends TypeParamType> typeParamTypes,
+                List<? extends Type> paramTypes,
                 Type returnType,
                 List<? extends Type> throwsTypes) {
-            this.typeArgTypes = typeArgTypes;
-            this.argTypes = argTypes;
+            this.typeParamTypes = typeParamTypes;
+            this.paramTypes = paramTypes;
             this.returnType = returnType;
             this.throwsTypes = throwsTypes;
         }
@@ -130,22 +165,32 @@
         @Override
         public String toString() {
             StringBuilder sb = new StringBuilder();
-            appendIfNotEmpty(sb, "<", typeArgTypes, "> ");
+            appendIfNotEmpty(sb, "<", typeParamTypes, "> ");
             sb.append(returnType);
-            append(sb, " (", argTypes, ")");
+            append(sb, " (", paramTypes, ")");
             appendIfNotEmpty(sb, " throws ", throwsTypes, "");
             return sb.toString();
         }
 
-        public final List<? extends Type> typeArgTypes;
-        public final List<? extends Type> argTypes;
+        public final List<? extends TypeParamType> typeParamTypes;
+        public final List<? extends Type> paramTypes;
         public final Type returnType;
         public final List<? extends Type> throwsTypes;
     }
 
+    /**
+     * Represents a class signature. These describe the signature of
+     * a class that has type arguments.
+     *
+     * See:
+     * JVMS 4.3.4
+     *      ClassSignature:
+     *          FormalTypeParameters_opt SuperclassSignature SuperinterfaceSignature*
+     */
     public static class ClassSigType extends Type {
-        public ClassSigType(List<Type> typeArgTypes, Type superclassType, List<Type> superinterfaceTypes) {
-            this.typeArgTypes = typeArgTypes;
+        public ClassSigType(List<TypeParamType> typeParamTypes, Type superclassType,
+                List<Type> superinterfaceTypes) {
+            this.typeParamTypes = typeParamTypes;
             this.superclassType = superclassType;
             this.superinterfaceTypes = superinterfaceTypes;
         }
@@ -157,7 +202,7 @@
         @Override
         public String toString() {
             StringBuilder sb = new StringBuilder();
-            appendIfNotEmpty(sb, "<", typeArgTypes, ">");
+            appendIfNotEmpty(sb, "<", typeParamTypes, ">");
             if (superclassType != null) {
                 sb.append(" extends ");
                 sb.append(superclassType);
@@ -166,13 +211,30 @@
             return sb.toString();
         }
 
-        public final List<Type> typeArgTypes;
+        public final List<TypeParamType> typeParamTypes;
         public final Type superclassType;
         public final List<Type> superinterfaceTypes;
     }
 
+    /**
+     * Represents a class type signature. This is used to represent a
+     * reference to a class, such as in a field, parameter, return type, etc.
+     *
+     * See:
+     * JVMS 4.3.4
+     *      ClassTypeSignature:
+     *          {@code L} PackageSpecifier_opt SimpleClassTypeSignature
+     *                  ClassTypeSignatureSuffix* {@code ;}
+     *      PackageSpecifier:
+     *          Identifier {@code /} PackageSpecifier*
+     *      SimpleClassTypeSignature:
+     *          Identifier TypeArguments_opt }
+     *      ClassTypeSignatureSuffix:
+     *          {@code .} SimpleClassTypeSignature
+     */
     public static class ClassType extends Type {
-        public ClassType(String name, List<Type> typeArgs) {
+        public ClassType(ClassType outerType, String name, List<Type> typeArgs) {
+            this.outerType = outerType;
             this.name = name;
             this.typeArgs = typeArgs;
         }
@@ -181,47 +243,54 @@
             return visitor.visitClassType(this, data);
         }
 
+        public String getBinaryName() {
+            if (outerType == null)
+                return name;
+            else
+                return (outerType.getBinaryName() + "$" + name);
+        }
+
         @Override
         public String toString() {
             StringBuilder sb = new StringBuilder();
+            if (outerType != null) {
+                sb.append(outerType);
+                sb.append(".");
+            }
             sb.append(name);
             appendIfNotEmpty(sb, "<", typeArgs, ">");
             return sb.toString();
         }
 
+        public final ClassType outerType;
         public final String name;
         public final List<Type> typeArgs;
     }
 
-
-    public static class InnerClassType extends Type {
-        public InnerClassType(Type outerType, Type innerType) {
-            this.outerType = outerType;
-            this.innerType = innerType;
-        }
-
-        public <R, D> R accept(Visitor<R, D> visitor, D data) {
-            return visitor.visitInnerClassType(this, data);
-        }
-
-        @Override
-        public String toString() {
-            return outerType + "." + innerType;
-        }
-
-        public final Type outerType;
-        public final Type innerType;
-    }
-
-    public static class TypeArgType extends Type {
-        public TypeArgType(String name, Type classBound, List<Type> interfaceBounds) {
+    /**
+     * Represents a FormalTypeParameter. These are used to declare the type
+     * parameters for generic classes and methods.
+     *
+     * See:
+     * JVMS 4.3.4
+     *     FormalTypeParameters:
+     *          {@code <} FormalTypeParameter+ {@code >}
+     *     FormalTypeParameter:
+     *          Identifier ClassBound InterfaceBound*
+     *     ClassBound:
+     *          {@code :} FieldTypeSignature_opt
+     *     InterfaceBound:
+     *          {@code :} FieldTypeSignature
+     */
+    public static class TypeParamType extends Type {
+        public TypeParamType(String name, Type classBound, List<Type> interfaceBounds) {
             this.name = name;
             this.classBound = classBound;
             this.interfaceBounds = interfaceBounds;
         }
 
         public <R, D> R accept(Visitor<R, D> visitor, D data) {
-            return visitor.visitTypeArgType(this, data);
+            return visitor.visitTypeParamType(this, data);
         }
 
         @Override
@@ -249,12 +318,25 @@
         public final List<Type> interfaceBounds;
     }
 
+    /**
+     * Represents a wildcard type argument.  A type argument that is not a
+     * wildcard type argument will be represented by a ClassType, ArrayType, etc.
+     *
+     * See:
+     * JVMS 4.3.4
+     *      TypeArgument:
+     *          WildcardIndicator_opt FieldTypeSignature
+     *          {@code *}
+     *      WildcardIndicator:
+     *          {@code +}
+     *          {@code -}
+     */
     public static class WildcardType extends Type {
+        public enum Kind { UNBOUNDED, EXTENDS, SUPER };
         public WildcardType() {
-            this(null, null);
+            this(Kind.UNBOUNDED, null);
         }
-
-        public WildcardType(String kind, Type boundType) {
+        public WildcardType(Kind kind, Type boundType) {
             this.kind = kind;
             this.boundType = boundType;
         }
@@ -265,13 +347,19 @@
 
         @Override
         public String toString() {
-            if (kind == null)
-                return "?";
-            else
-                return "? " + kind + " " + boundType;
+            switch (kind) {
+                case UNBOUNDED:
+                    return "?";
+                case EXTENDS:
+                    return "? extends " + boundType;
+                case SUPER:
+                    return "? super " + boundType;
+                default:
+                    throw new AssertionError();
+            }
         }
 
-        public final String kind;
+        public final Kind kind;
         public final Type boundType;
     }
 }
--- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Sat Oct 31 08:52:31 2009 -0700
@@ -1212,25 +1212,58 @@
         public List<VarSymbol> params() {
             owner.complete();
             if (params == null) {
-                List<Name> names = savedParameterNames;
+                // If ClassReader.saveParameterNames has been set true, then
+                // savedParameterNames will be set to a list of names that
+                // matches the types in type.getParameterTypes().  If any names
+                // were not found in the class file, those names in the list will
+                // be set to the empty name.
+                // If ClassReader.saveParameterNames has been set false, then
+                // savedParameterNames will be null.
+                List<Name> paramNames = savedParameterNames;
                 savedParameterNames = null;
-                if (names == null) {
-                    names = List.nil();
-                    int i = 0;
-                    for (Type t : type.getParameterTypes())
-                        names = names.prepend(name.table.fromString("arg" + i++));
-                    names = names.reverse();
-                }
+                // discard the provided names if the list of names is the wrong size.
+                if (paramNames == null || paramNames.size() != type.getParameterTypes().size())
+                    paramNames = List.nil();
                 ListBuffer<VarSymbol> buf = new ListBuffer<VarSymbol>();
+                List<Name> remaining = paramNames;
+                // assert: remaining and paramNames are both empty or both
+                // have same cardinality as type.getParameterTypes()
+                int i = 0;
                 for (Type t : type.getParameterTypes()) {
-                    buf.append(new VarSymbol(PARAMETER, names.head, t, this));
-                    names = names.tail;
+                    Name paramName;
+                    if (remaining.isEmpty()) {
+                        // no names for any parameters available
+                        paramName = createArgName(i, paramNames);
+                    } else {
+                        paramName = remaining.head;
+                        remaining = remaining.tail;
+                        if (paramName.isEmpty()) {
+                            // no name for this specific parameter
+                            paramName = createArgName(i, paramNames);
+                        }
+                    }
+                    buf.append(new VarSymbol(PARAMETER, paramName, t, this));
+                    i++;
                 }
                 params = buf.toList();
             }
             return params;
         }
 
+        // Create a name for the argument at position 'index' that is not in
+        // the exclude list. In normal use, either no names will have been
+        // provided, in which case the exclude list is empty, or all the names
+        // will have been provided, in which case this method will not be called.
+        private Name createArgName(int index, List<Name> exclude) {
+            String prefix = "arg";
+            while (true) {
+                Name argName = name.table.fromString(prefix + index);
+                if (!exclude.contains(argName))
+                    return argName;
+                prefix += "$";
+            }
+        }
+
         public Symbol asMemberOf(Type site, Types types) {
             return new MethodSymbol(flags_field, name, types.memberType(site, this), owner);
         }
--- a/src/share/classes/com/sun/tools/javac/file/BaseFileObject.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/BaseFileObject.java	Sat Oct 31 08:52:31 2009 -0700
@@ -120,6 +120,14 @@
 
     }
 
+    // force subtypes to define equals
+    @Override
+    public abstract boolean equals(Object other);
+
+    // force subtypes to define hashCode
+    @Override
+    public abstract int hashCode();
+
     /** The file manager that created this JavaFileObject. */
     protected final JavacFileManager fileManager;
 }
--- a/src/share/classes/com/sun/tools/javac/file/JavacFileManager.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/JavacFileManager.java	Sat Oct 31 08:52:31 2009 -0700
@@ -968,7 +968,7 @@
             } else {
                 File siblingDir = null;
                 if (sibling != null && sibling instanceof RegularFileObject) {
-                    siblingDir = ((RegularFileObject)sibling).f.getParentFile();
+                    siblingDir = ((RegularFileObject)sibling).file.getParentFile();
                 }
                 return new RegularFileObject(this, new File(siblingDir, fileName.basename()));
             }
--- a/src/share/classes/com/sun/tools/javac/file/RegularFileObject.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/RegularFileObject.java	Sat Oct 31 08:52:31 2009 -0700
@@ -33,6 +33,8 @@
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
 import java.net.URI;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
@@ -53,7 +55,8 @@
      */
     private boolean hasParents = false;
     private String name;
-    final File f;
+    final File file;
+    private Reference<File> absFileRef;
 
     public RegularFileObject(JavacFileManager fileManager, File f) {
         this(fileManager, f.getName(), f);
@@ -65,17 +68,17 @@
             throw new IllegalArgumentException("directories not supported");
         }
         this.name = name;
-        this.f = f;
+        this.file = f;
     }
 
     @Override
     public URI toUri() {
-        return f.toURI().normalize();
+        return file.toURI().normalize();
     }
 
     @Override
     public String getName() {
-        return f.getPath();
+        return file.getPath();
     }
 
     @Override
@@ -90,20 +93,20 @@
 
     @Override
     public InputStream openInputStream() throws IOException {
-        return new FileInputStream(f);
+        return new FileInputStream(file);
     }
 
     @Override
     public OutputStream openOutputStream() throws IOException {
         ensureParentDirectoriesExist();
-        return new FileOutputStream(f);
+        return new FileOutputStream(file);
     }
 
     @Override
     public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
         CharBuffer cb = fileManager.getCachedContent(this);
         if (cb == null) {
-            InputStream in = new FileInputStream(f);
+            InputStream in = new FileInputStream(file);
             try {
                 ByteBuffer bb = fileManager.makeByteBuffer(in);
                 JavaFileObject prev = fileManager.log.useSource(this);
@@ -126,17 +129,17 @@
     @Override
     public Writer openWriter() throws IOException {
         ensureParentDirectoriesExist();
-        return new OutputStreamWriter(new FileOutputStream(f), fileManager.getEncodingName());
+        return new OutputStreamWriter(new FileOutputStream(file), fileManager.getEncodingName());
     }
 
     @Override
     public long getLastModified() {
-        return f.lastModified();
+        return file.lastModified();
     }
 
     @Override
     public boolean delete() {
-        return f.delete();
+        return file.delete();
     }
 
     @Override
@@ -146,7 +149,7 @@
 
     @Override
     protected String inferBinaryName(Iterable<? extends File> path) {
-        String fPath = f.getPath();
+        String fPath = file.getPath();
         //System.err.println("RegularFileObject " + file + " " +r.getPath());
         for (File dir: path) {
             //System.err.println("dir: " + dir);
@@ -178,7 +181,7 @@
         if (name.equalsIgnoreCase(n)) {
             try {
                 // allow for Windows
-                return f.getCanonicalFile().getName().equals(n);
+                return file.getCanonicalFile().getName().equals(n);
             } catch (IOException e) {
             }
         }
@@ -187,7 +190,7 @@
 
     private void ensureParentDirectoriesExist() throws IOException {
         if (!hasParents) {
-            File parent = f.getParentFile();
+            File parent = file.getParentFile();
             if (parent != null && !parent.exists()) {
                 if (!parent.mkdirs()) {
                     if (!parent.exists() || !parent.isDirectory()) {
@@ -199,21 +202,34 @@
         }
     }
 
+    /**
+     * Check if two file objects are equal.
+     * Two RegularFileObjects are equal if the absolute paths of the underlying
+     * files are equal.
+     */
     @Override
     public boolean equals(Object other) {
-        if (!(other instanceof RegularFileObject)) {
+        if (this == other)
+            return true;
+
+        if (!(other instanceof RegularFileObject))
             return false;
-        }
+
         RegularFileObject o = (RegularFileObject) other;
-        try {
-            return f.equals(o.f) || f.getCanonicalFile().equals(o.f.getCanonicalFile());
-        } catch (IOException e) {
-            return false;
-        }
+        return getAbsoluteFile().equals(o.getAbsoluteFile());
     }
 
     @Override
     public int hashCode() {
-        return f.hashCode();
+        return getAbsoluteFile().hashCode();
+    }
+
+    private File getAbsoluteFile() {
+        File absFile = (absFileRef == null ? null : absFileRef.get());
+        if (absFile == null) {
+            absFile = file.getAbsoluteFile();
+            absFileRef = new SoftReference<File>(absFile);
+        }
+        return absFile;
     }
 }
--- a/src/share/classes/com/sun/tools/javac/file/SymbolArchive.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/SymbolArchive.java	Sat Oct 31 08:52:31 2009 -0700
@@ -76,13 +76,13 @@
     @Override
     public JavaFileObject getFileObject(RelativeDirectory subdirectory, String file) {
         RelativeDirectory prefix_subdir = new RelativeDirectory(prefix, subdirectory.path);
-        ZipEntry ze = new RelativeFile(prefix_subdir, file).getZipEntry(zdir);
+        ZipEntry ze = new RelativeFile(prefix_subdir, file).getZipEntry(zfile);
         return new SymbolFileObject(this, file, ze);
     }
 
     @Override
     public String toString() {
-        return "SymbolArchive[" + zdir.getName() + "]";
+        return "SymbolArchive[" + zfile.getName() + "]";
     }
 
     /**
--- a/src/share/classes/com/sun/tools/javac/file/ZipArchive.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/ZipArchive.java	Sat Oct 31 08:52:31 2009 -0700
@@ -47,6 +47,8 @@
 import com.sun.tools.javac.file.RelativePath.RelativeDirectory;
 import com.sun.tools.javac.file.RelativePath.RelativeFile;
 import com.sun.tools.javac.util.List;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
 
 /**
  * <p><b>This is NOT part of any API supported by Sun Microsystems.
@@ -56,20 +58,20 @@
  */
 public class ZipArchive implements Archive {
 
-    public ZipArchive(JavacFileManager fm, ZipFile zdir) throws IOException {
-        this(fm, zdir, true);
+    public ZipArchive(JavacFileManager fm, ZipFile zfile) throws IOException {
+        this(fm, zfile, true);
     }
 
-    protected ZipArchive(JavacFileManager fm, ZipFile zdir, boolean initMap) throws IOException {
+    protected ZipArchive(JavacFileManager fm, ZipFile zfile, boolean initMap) throws IOException {
         this.fileManager = fm;
-        this.zdir = zdir;
+        this.zfile = zfile;
         this.map = new HashMap<RelativeDirectory,List<String>>();
         if (initMap)
             initMap();
     }
 
     protected void initMap() throws IOException {
-        for (Enumeration<? extends ZipEntry> e = zdir.entries(); e.hasMoreElements(); ) {
+        for (Enumeration<? extends ZipEntry> e = zfile.entries(); e.hasMoreElements(); ) {
             ZipEntry entry;
             try {
                 entry = e.nextElement();
@@ -110,7 +112,7 @@
     }
 
     public JavaFileObject getFileObject(RelativeDirectory subdirectory, String file) {
-        ZipEntry ze = new RelativeFile(subdirectory, file).getZipEntry(zdir);
+        ZipEntry ze = new RelativeFile(subdirectory, file).getZipEntry(zfile);
         return new ZipFileObject(this, file, ze);
     }
 
@@ -119,17 +121,39 @@
     }
 
     public void close() throws IOException {
-        zdir.close();
+        zfile.close();
     }
 
     @Override
     public String toString() {
-        return "ZipArchive[" + zdir.getName() + "]";
+        return "ZipArchive[" + zfile.getName() + "]";
     }
 
+    private File getAbsoluteFile() {
+        File absFile = (absFileRef == null ? null : absFileRef.get());
+        if (absFile == null) {
+            absFile = new File(zfile.getName()).getAbsoluteFile();
+            absFileRef = new SoftReference<File>(absFile);
+        }
+        return absFile;
+    }
+
+    /**
+     * The file manager that created this archive.
+     */
     protected JavacFileManager fileManager;
+    /**
+     * The index for the contents of this archive.
+     */
     protected final Map<RelativeDirectory,List<String>> map;
-    protected final ZipFile zdir;
+    /**
+     * The zip file for the archive.
+     */
+    protected final ZipFile zfile;
+    /**
+     * A reference to the absolute filename for the zip file for the archive.
+     */
+    protected Reference<File> absFileRef;
 
     /**
      * A subclass of JavaFileObject representing zip entries.
@@ -148,18 +172,18 @@
         }
 
         public URI toUri() {
-            File zipFile = new File(zarch.zdir.getName());
+            File zipFile = new File(zarch.zfile.getName());
             return createJarUri(zipFile, entry.getName());
         }
 
         @Override
         public String getName() {
-            return zarch.zdir.getName() + "(" + entry.getName() + ")";
+            return zarch.zfile.getName() + "(" + entry.getName() + ")";
         }
 
         @Override
         public String getShortName() {
-            return new File(zarch.zdir.getName()).getName() + "(" + entry + ")";
+            return new File(zarch.zfile.getName()).getName() + "(" + entry + ")";
         }
 
         @Override
@@ -169,7 +193,7 @@
 
         @Override
         public InputStream openInputStream() throws IOException {
-            return zarch.zdir.getInputStream(entry);
+            return zarch.zfile.getInputStream(entry);
         }
 
         @Override
@@ -181,7 +205,7 @@
         public CharBuffer getCharContent(boolean ignoreEncodingErrors) throws IOException {
             CharBuffer cb = fileManager.getCachedContent(this);
             if (cb == null) {
-                InputStream in = zarch.zdir.getInputStream(entry);
+                InputStream in = zarch.zfile.getInputStream(entry);
                 try {
                     ByteBuffer bb = fileManager.makeByteBuffer(in);
                     JavaFileObject prev = fileManager.log.useSource(this);
@@ -237,18 +261,27 @@
             return name.equals(cn + k.extension);
         }
 
+        /**
+         * Check if two file objects are equal.
+         * Two ZipFileObjects are equal if the absolute paths of the underlying
+         * zip files are equal and if the paths within those zip files are equal.
+         */
         @Override
         public boolean equals(Object other) {
-            if (!(other instanceof ZipFileObject)) {
+            if (this == other)
+                return true;
+
+            if (!(other instanceof ZipFileObject))
                 return false;
-            }
+
             ZipFileObject o = (ZipFileObject) other;
-            return zarch.zdir.equals(o.zarch.zdir) || name.equals(o.name);
+            return zarch.getAbsoluteFile().equals(o.zarch.getAbsoluteFile())
+                    && name.equals(o.name);
         }
 
         @Override
         public int hashCode() {
-            return zarch.zdir.hashCode() + name.hashCode();
+            return zarch.getAbsoluteFile().hashCode() + name.hashCode();
         }
     }
 
--- a/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/ZipFileIndex.java	Sat Oct 31 08:52:31 2009 -0700
@@ -30,6 +30,7 @@
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.RandomAccessFile;
+import java.lang.ref.Reference;
 import java.lang.ref.SoftReference;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -89,6 +90,7 @@
 
     // ZipFileIndex data entries
     private File zipFile;
+    private Reference<File> absFileRef;
     private long zipFileLastModified = NOT_MODIFIED;
     private RandomAccessFile zipRandomFile;
     private Entry[] entries;
@@ -1215,6 +1217,15 @@
         return zipFile;
     }
 
+    File getAbsoluteFile() {
+        File absFile = (absFileRef == null ? null : absFileRef.get());
+        if (absFile == null) {
+            absFile = zipFile.getAbsoluteFile();
+            absFileRef = new SoftReference<File>(absFile);
+        }
+        return absFile;
+    }
+
     private RelativeDirectory getRelativeDirectory(String path) {
         RelativeDirectory rd;
         SoftReference<RelativeDirectory> ref = relativeDirectoryCache.get(path);
--- a/src/share/classes/com/sun/tools/javac/file/ZipFileIndexArchive.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/file/ZipFileIndexArchive.java	Sat Oct 31 08:52:31 2009 -0700
@@ -219,17 +219,27 @@
             return name.equals(cn + k.extension);
         }
 
+        /**
+         * Check if two file objects are equal.
+         * Two ZipFileIndexFileObjects are equal if the absolute paths of the underlying
+         * zip files are equal and if the paths within those zip files are equal.
+         */
         @Override
         public boolean equals(Object other) {
+            if (this == other)
+                return true;
+
             if (!(other instanceof ZipFileIndexFileObject))
                 return false;
+
             ZipFileIndexFileObject o = (ZipFileIndexFileObject) other;
-            return entry.equals(o.entry);
+            return zfIndex.getAbsoluteFile().equals(o.zfIndex.getAbsoluteFile())
+                    && name.equals(o.name);
         }
 
         @Override
         public int hashCode() {
-            return zipName.hashCode() + (name.hashCode() << 10);
+            return zfIndex.getAbsoluteFile().hashCode() + name.hashCode();
         }
 
         private String getPrefixedEntryName() {
--- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Sat Oct 31 08:52:31 2009 -0700
@@ -29,6 +29,7 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.CharBuffer;
+import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
@@ -191,6 +192,16 @@
      */
     boolean debugJSR308;
 
+    /** A table to hold the constant pool indices for method parameter
+     * names, as given in LocalVariableTable attributes.
+     */
+    int[] parameterNameIndices;
+
+    /**
+     * Whether or not any parameter names have been found.
+     */
+    boolean haveParameterNameIndices;
+
     /** Get the ClassReader instance for this invocation. */
     public static ClassReader instance(Context context) {
         ClassReader instance = context.get(classReaderKey);
@@ -922,32 +933,33 @@
                 void read(Symbol sym, int attrLen) {
                     int newbp = bp + attrLen;
                     if (saveParameterNames) {
-                        // pick up parameter names from the variable table
-                        List<Name> parameterNames = List.nil();
-                        int firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
-                        int endParam = firstParam + Code.width(sym.type.getParameterTypes());
+                        // Pick up parameter names from the variable table.
+                        // Parameter names are not explicitly identified as such,
+                        // but all parameter name entries in the LocalVariableTable
+                        // have a start_pc of 0.  Therefore, we record the name
+                        // indicies of all slots with a start_pc of zero in the
+                        // parameterNameIndicies array.
+                        // Note that this implicitly honors the JVMS spec that
+                        // there may be more than one LocalVariableTable, and that
+                        // there is no specified ordering for the entries.
                         int numEntries = nextChar();
-                        for (int i=0; i<numEntries; i++) {
+                        for (int i = 0; i < numEntries; i++) {
                             int start_pc = nextChar();
                             int length = nextChar();
                             int nameIndex = nextChar();
                             int sigIndex = nextChar();
                             int register = nextChar();
-                            if (start_pc == 0 &&
-                                firstParam <= register &&
-                                register < endParam) {
-                                int index = firstParam;
-                                for (Type t : sym.type.getParameterTypes()) {
-                                    if (index == register) {
-                                        parameterNames = parameterNames.prepend(readName(nameIndex));
-                                        break;
-                                    }
-                                    index += Code.width(t);
+                            if (start_pc == 0) {
+                                // ensure array large enough
+                                if (register >= parameterNameIndices.length) {
+                                    int newSize = Math.max(register, parameterNameIndices.length + 8);
+                                    parameterNameIndices =
+                                            Arrays.copyOf(parameterNameIndices, newSize);
                                 }
+                                parameterNameIndices[register] = nameIndex;
+                                haveParameterNameIndices = true;
                             }
                         }
-                        parameterNames = parameterNames.reverse();
-                        ((MethodSymbol)sym).savedParameterNames = parameterNames;
                     }
                     bp = newbp;
                 }
@@ -1839,6 +1851,8 @@
                                       syms.methodClass);
         }
         MethodSymbol m = new MethodSymbol(flags, name, type, currentOwner);
+        if (saveParameterNames)
+            initParameterNames(m);
         Symbol prevOwner = currentOwner;
         currentOwner = m;
         try {
@@ -1846,9 +1860,90 @@
         } finally {
             currentOwner = prevOwner;
         }
+        if (saveParameterNames)
+            setParameterNames(m, type);
         return m;
     }
 
+    /**
+     * Init the parameter names array.
+     * Parameter names are currently inferred from the names in the
+     * LocalVariableTable attributes of a Code attribute.
+     * (Note: this means parameter names are currently not available for
+     * methods without a Code attribute.)
+     * This method initializes an array in which to store the name indexes
+     * of parameter names found in LocalVariableTable attributes. It is
+     * slightly supersized to allow for additional slots with a start_pc of 0.
+     */
+    void initParameterNames(MethodSymbol sym) {
+        // make allowance for synthetic parameters.
+        final int excessSlots = 4;
+        int expectedParameterSlots =
+                Code.width(sym.type.getParameterTypes()) + excessSlots;
+        if (parameterNameIndices == null
+                || parameterNameIndices.length < expectedParameterSlots) {
+            parameterNameIndices = new int[expectedParameterSlots];
+        } else
+            Arrays.fill(parameterNameIndices, 0);
+        haveParameterNameIndices = false;
+    }
+
+    /**
+     * Set the parameter names for a symbol from the name index in the
+     * parameterNameIndicies array. The type of the symbol may have changed
+     * while reading the method attributes (see the Signature attribute).
+     * This may be because of generic information or because anonymous
+     * synthetic parameters were added.   The original type (as read from
+     * the method descriptor) is used to help guess the existence of
+     * anonymous synthetic parameters.
+     * On completion, sym.savedParameter names will either be null (if
+     * no parameter names were found in the class file) or will be set to a
+     * list of names, one per entry in sym.type.getParameterTypes, with
+     * any missing names represented by the empty name.
+     */
+    void setParameterNames(MethodSymbol sym, Type jvmType) {
+        // if no names were found in the class file, there's nothing more to do
+        if (!haveParameterNameIndices)
+            return;
+
+        int firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
+        // the code in readMethod may have skipped the first parameter when
+        // setting up the MethodType. If so, we make a corresponding allowance
+        // here for the position of the first parameter.  Note that this
+        // assumes the skipped parameter has a width of 1 -- i.e. it is not
+        // a double width type (long or double.)
+        if (sym.name == names.init && currentOwner.hasOuterInstance()) {
+            // Sometimes anonymous classes don't have an outer
+            // instance, however, there is no reliable way to tell so
+            // we never strip this$n
+            if (!currentOwner.name.isEmpty())
+                firstParam += 1;
+        }
+
+        if (sym.type != jvmType) {
+            // reading the method attributes has caused the symbol's type to
+            // be changed. (i.e. the Signature attribute.)  This may happen if
+            // there are hidden (synthetic) parameters in the descriptor, but
+            // not in the Signature.  The position of these hidden parameters
+            // is unspecified; for now, assume they are at the beginning, and
+            // so skip over them. The primary case for this is two hidden
+            // parameters passed into Enum constructors.
+            int skip = Code.width(jvmType.getParameterTypes())
+                    - Code.width(sym.type.getParameterTypes());
+            firstParam += skip;
+        }
+        List<Name> paramNames = List.nil();
+        int index = firstParam;
+        for (Type t: sym.type.getParameterTypes()) {
+            int nameIdx = (index < parameterNameIndices.length
+                    ? parameterNameIndices[index] : 0);
+            Name name = nameIdx == 0 ? names.empty : readName(nameIdx);
+            paramNames = paramNames.prepend(name);
+            index += Code.width(t);
+        }
+        sym.savedParameterNames = paramNames.reverse();
+    }
+
     /** Skip a field or method
      */
     void skipMember() {
@@ -2632,10 +2727,20 @@
             return true; // fail-safe mode
         }
 
+        /**
+         * Check if two file objects are equal.
+         * SourceFileObjects are just placeholder objects for the value of a
+         * SourceFile attribute, and do not directly represent specific files.
+         * Two SourceFileObjects are equal if their names are equal.
+         */
         @Override
         public boolean equals(Object other) {
+            if (this == other)
+                return true;
+
             if (!(other instanceof SourceFileObject))
                 return false;
+
             SourceFileObject o = (SourceFileObject) other;
             return name.equals(o.name);
         }
--- a/src/share/classes/com/sun/tools/javac/parser/Scanner.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/parser/Scanner.java	Sat Oct 31 08:52:31 2009 -0700
@@ -876,7 +876,11 @@
                         }
                         scanChar();
                         skipIllegalUnderscores();
-                        scanNumber(2);
+                        if (digit(2) < 0) {
+                            lexError("invalid.binary.number");
+                        } else {
+                            scanNumber(2);
+                        }
                     } else {
                         putChar('0');
                         if (ch == '_') {
--- a/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Sat Oct 31 08:52:31 2009 -0700
@@ -252,6 +252,8 @@
     interface methods cannot have body
 compiler.err.invalid.annotation.member.type=\
     invalid type for annotation member
+compiler.err.invalid.binary.number=\
+    binary numbers must contain at least one binary digit
 compiler.err.invalid.hex.number=\
     hexadecimal numbers must contain at least one hexadecimal digit
 compiler.err.invalid.meth.decl.ret.type.req=\
--- a/src/share/classes/com/sun/tools/javap/ClassWriter.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javap/ClassWriter.java	Sat Oct 31 08:52:31 2009 -0700
@@ -179,10 +179,10 @@
                 // The signature parser cannot disambiguate between a
                 // FieldType and a ClassSignatureType that only contains a superclass type.
                 if (t instanceof Type.ClassSigType)
-                    print(t);
+                    print(getJavaName(t.toString()));
                 else {
                     print(" extends ");
-                    print(t);
+                    print(getJavaName(t.toString()));
                 }
             } catch (ConstantPoolException e) {
                 print(report(e));
@@ -310,7 +310,7 @@
 
         writeModifiers(flags.getMethodModifiers());
         if (methodType != null) {
-            writeListIfNotEmpty("<", methodType.typeArgTypes, "> ");
+            writeListIfNotEmpty("<", methodType.typeParamTypes, "> ");
         }
         if (getName(m).equals("<init>")) {
             print(getJavaName(classFile));
--- a/src/share/classes/com/sun/tools/javap/LocalVariableTypeTableWriter.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/com/sun/tools/javap/LocalVariableTypeTableWriter.java	Sat Oct 31 08:52:31 2009 -0700
@@ -125,7 +125,7 @@
                     print(" // ");
                     Descriptor d = new Signature(entry.signature_index);
                     try {
-                        print(d.getFieldType(constant_pool));
+                        print(d.getFieldType(constant_pool).toString().replace("/", "."));
                     } catch (InvalidDescriptor e) {
                         print(report(e));
                     } catch (ConstantPoolException e) {
--- a/src/share/classes/javax/lang/model/util/Elements.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/src/share/classes/javax/lang/model/util/Elements.java	Sat Oct 31 08:52:31 2009 -0700
@@ -77,9 +77,25 @@
      * Returns the text of the documentation (&quot;Javadoc&quot;)
      * comment of an element.
      *
+     * <p> A documentation comment of an element is a comment that
+     * begins with "{@code /**}" , ends with a separate
+     * "<code>*&#47</code>", and immediately precedes the element,
+     * ignoring white space.  Therefore, a documentation comment
+     * contains at least three"{@code *}" characters.  The text
+     * returned for the documentation comment is a processed form of
+     * the comment as it appears in source code.  The leading "{@code
+     * /**}" and trailing "<code>*&#47</code>" are removed.  For lines
+     * of the comment starting after the initial "{@code /**}",
+     * leading white space characters are discarded as are any
+     * consecutive "{@code *}" characters appearing after the white
+     * space or starting the line.  The processed lines are then
+     * concatenated together (including line terminators) and
+     * returned.
+     *
      * @param e  the element being examined
      * @return the documentation comment of the element, or {@code null}
      *          if there is none
+     * @jls3 3.6 White Space
      */
     String getDocComment(Element e);
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/6889255/T6889255.java	Sat Oct 31 08:52:31 2009 -0700
@@ -0,0 +1,485 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/*
+ * @test
+ * @bug 6889255
+ * @summary ClassReader does not read parameter names correctly
+ */
+
+import java.io.*;
+import java.util.*;
+import javax.tools.StandardLocation;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Scope;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.Type.ClassType;
+import com.sun.tools.javac.code.TypeTags;
+import com.sun.tools.javac.file.JavacFileManager;
+import com.sun.tools.javac.jvm.ClassReader;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Names;
+
+public class T6889255 {
+    boolean testInterfaces = true;
+    boolean testSyntheticMethods = true;
+
+    // The following enums control the generation of the test methods to be compiled.
+    enum GenericKind {
+        NOT_GENERIC,
+        GENERIC
+    };
+
+    enum ClassKind {
+        CLASS("Clss"),
+        INTERFACE("Intf"),
+        ENUM("Enum");
+        final String base;
+        ClassKind(String base) { this.base = base; }
+    };
+
+    enum NestedKind {
+        /** Declare methods inside the outermost container. */
+        NONE,
+        /** Declare methods inside a container with a 'static' modifier. */
+        NESTED,
+        /** Declare methods inside a container without a 'static' modifier. */
+        INNER,
+        /** Declare methods inside a local class in an initializer. */
+        INIT_LOCAL,
+        /** Declare methods inside an anonymous class in an initializer. */
+        INIT_ANON,
+        /** Declare methods inside a local class in a method. */
+        METHOD_LOCAL,
+        /** Declare methods inside an anonymous class in a method. */
+        METHOD_ANON
+    };
+
+    enum MethodKind {
+        ABSTRACT,
+        CONSTRUCTOR,
+        METHOD,
+        STATIC_METHOD,
+        BRIDGE_METHOD
+    };
+
+    enum FinalKind {
+        /** Method body does not reference external final variables. */
+        NO_FINAL,
+        /** Method body references external final variables. */
+        USE_FINAL
+    };
+
+    public static void main(String... args) throws Exception {
+        new T6889255().run();
+    }
+
+    void run() throws Exception {
+        genTest();
+
+        test("no-args", false);
+        test("g",       true,  "-g");
+
+        if (errors > 0)
+            throw new Exception(errors + " errors found");
+    }
+
+    /**
+     * Create a file containing lots of method definitions to be tested.
+     * There are 3 sets of nested loops that generate the methods.
+     * 1. The outermost set declares [generic] (class | interface | enum)
+     * 2. The middle set declares [(nested | inner | anon | local)] class
+     * 3. The innermost set declares
+     *      [generic] (constructor|method|static-method|bridge-method) [using final variables in outer scope]
+     * Invalid combinations are filtered out.
+     */
+    void genTest() throws Exception {
+        BufferedWriter out = new BufferedWriter(new FileWriter("Test.java"));
+
+        // This interface is used to force bridge methods to be generated, by
+        // implementing its methods with subtypes of Object
+        out.write("interface Base {\n");
+        out.write("    Object base_m1(int i1);\n");
+        out.write("    Object base_m2(int i1);\n");
+        out.write("}\n");
+
+        int outerNum = 0;
+        // Outermost set of loops, to generate a top level container
+        for (GenericKind outerGenericKind: GenericKind.values()) {
+            for (ClassKind outerClassKind: ClassKind.values()) {
+                if (outerGenericKind == GenericKind.GENERIC && outerClassKind == ClassKind.ENUM)
+                    continue;
+                String outerClassName = outerClassKind.base + (outerNum++);
+                String outerTypeArg = outerClassKind.toString().charAt(0) + "T";
+                if (outerClassKind == ClassKind.CLASS)
+                    out.write("abstract ");
+                out.write(outerClassKind.toString().toLowerCase() + " " + outerClassName);
+                if (outerGenericKind == GenericKind.GENERIC)
+                    out.write("<" + outerTypeArg + ">");
+                if (outerClassKind == ClassKind.INTERFACE)
+                    out.write(" extends Base");
+                else
+                    out.write(" implements Base");
+                out.write(" {\n");
+                if (outerClassKind == ClassKind.ENUM) {
+                    out.write("    E1(0,0,0), E2(0,0,0), E3(0,0,0);\n");
+                    out.write("    " + outerClassName + "(int i1, int i2, int i3) { }\n");
+                }
+                // Middle set of loops, to generate an optional nested container
+                int nestedNum = 0;
+                int methodNum = 0;
+                for (GenericKind nestedGenericKind: GenericKind.values()) {
+                    nextNestedKind:
+                    for (NestedKind nestedKind: NestedKind.values()) {
+                        // if the nested kind is none, there is no point iterating over all
+                        // nested generic kinds, so arbitarily limit it to just one kind
+                        if (nestedKind == NestedKind.NONE && nestedGenericKind != GenericKind.NOT_GENERIC)
+                            continue;
+                        if ((nestedKind == NestedKind.METHOD_ANON || nestedKind == NestedKind.INIT_ANON)
+                                && nestedGenericKind == GenericKind.GENERIC)
+                            continue;
+                        String indent = "    ";
+                        boolean haveFinal = false;
+                        switch (nestedKind) {
+                            case METHOD_ANON: case METHOD_LOCAL:
+                                if (outerClassKind == ClassKind.INTERFACE)
+                                    continue nextNestedKind;
+                                out.write(indent + "void m" +  + (nestedNum++) + "() {\n");
+                                indent += "    ";
+                                out.write(indent + "final int fi1 = 0;\n");
+                                haveFinal = true;
+                                break;
+                            case INIT_ANON: case INIT_LOCAL:
+                                if (outerClassKind == ClassKind.INTERFACE)
+                                    continue nextNestedKind;
+                                out.write(indent + "{\n");
+                                indent += "    ";
+                                break;
+                        }
+                        for (ClassKind nestedClassKind: ClassKind.values()) {
+                            if ((nestedGenericKind == GenericKind.GENERIC)
+                                    && (nestedClassKind == ClassKind.ENUM))
+                                continue;
+                            if ((nestedKind == NestedKind.METHOD_ANON || nestedKind == NestedKind.METHOD_LOCAL
+                                    || nestedKind == NestedKind.INIT_ANON || nestedKind == NestedKind.INIT_LOCAL)
+                                    && nestedClassKind != ClassKind.CLASS)
+                                continue;
+                            // if the nested kind is none, there is no point iterating over all
+                            // nested class kinds, so arbitarily limit it to just one kind
+                            if (nestedKind == NestedKind.NONE && nestedClassKind != ClassKind.CLASS)
+                                continue;
+
+                            ClassKind methodClassKind;
+                            String methodClassName;
+                            boolean allowAbstractMethods;
+                            boolean allowStaticMethods;
+                            switch (nestedKind) {
+                                case NONE:
+                                    methodClassKind = outerClassKind;
+                                    methodClassName = outerClassName;
+                                    allowAbstractMethods = (outerClassKind == ClassKind.CLASS);
+                                    allowStaticMethods = (outerClassKind != ClassKind.INTERFACE);
+                                    break;
+                                case METHOD_ANON:
+                                case INIT_ANON:
+                                    out.write(indent + "new Base() {\n");
+                                    indent += "    ";
+                                    methodClassKind = ClassKind.CLASS;
+                                    methodClassName = null;
+                                    allowAbstractMethods = false;
+                                    allowStaticMethods = false;
+                                    break;
+                                default: { // INNER, NESTED, LOCAL
+                                    String nestedClassName = "N" + nestedClassKind.base + (nestedNum++);
+                                    String nestedTypeArg = nestedClassKind.toString().charAt(0) + "T";
+                                    out.write(indent);
+                                    if (nestedKind == NestedKind.NESTED)
+                                        out.write("static ");
+                                    if (nestedClassKind == ClassKind.CLASS)
+                                        out.write("abstract ");
+                                    out.write(nestedClassKind.toString().toLowerCase() + " " + nestedClassName);
+                                    if (nestedGenericKind == GenericKind.GENERIC)
+                                        out.write("<" + nestedTypeArg + ">");
+                                    if (nestedClassKind == ClassKind.INTERFACE)
+                                        out.write(" extends Base ");
+                                    else
+                                        out.write(" implements Base ");
+                                    out.write(" {\n");
+                                    indent += "    ";
+                                    if (nestedClassKind == ClassKind.ENUM) {
+                                        out.write(indent + "E1(0,0,0), E2(0,0,0), E3(0,0,0);\n");
+                                        out.write(indent + nestedClassName + "(int i1, int i2, int i3) { }\n");
+                                    }
+                                    methodClassKind = nestedClassKind;
+                                    methodClassName = nestedClassName;
+                                    allowAbstractMethods = (nestedClassKind == ClassKind.CLASS);
+                                    allowStaticMethods = (nestedKind == NestedKind.NESTED && nestedClassKind != ClassKind.INTERFACE);
+                                    break;
+                                }
+                            }
+
+                            // Innermost loops, to generate methods
+                            for (GenericKind methodGenericKind: GenericKind.values()) {
+                                for (FinalKind finalKind: FinalKind.values()) {
+                                    for (MethodKind methodKind: MethodKind.values()) {
+//                                        out.write("// " + outerGenericKind
+//                                                + " " + outerClassKind
+//                                                + " " + nestedKind
+//                                                + " " + nestedGenericKind
+//                                                + " " + nestedClassKind
+//                                                + " " + methodGenericKind
+//                                                + " " + finalKind
+//                                                + " " + methodKind
+//                                                + "\n");
+                                        switch (methodKind) {
+                                            case CONSTRUCTOR:
+                                                if (nestedKind == NestedKind.METHOD_ANON || nestedKind == NestedKind.INIT_ANON)
+                                                    break;
+                                                if (methodClassKind != ClassKind.CLASS)
+                                                    break;
+                                                if (finalKind == FinalKind.USE_FINAL && !haveFinal)
+                                                    break;
+                                                out.write(indent);
+                                                if (methodGenericKind == GenericKind.GENERIC) {
+                                                    out.write("<CT> " + methodClassName + "(CT c1, CT c2");
+                                                } else {
+                                                    out.write(methodClassName + "(boolean b1, char c2");
+                                                }
+                                                if (finalKind == FinalKind.USE_FINAL) {
+                                                    // add a dummy parameter to avoid duplicate declaration
+                                                    out.write(", int i3) { int i = fi1; }\n");
+                                                } else
+                                                    out.write(") { }\n");
+                                                break;
+                                            case ABSTRACT:
+                                                if (!allowAbstractMethods)
+                                                    continue;
+                                                // fallthrough
+                                            case METHOD:
+                                                if (finalKind == FinalKind.USE_FINAL && !haveFinal)
+                                                    break;
+                                                out.write(indent);
+                                                if (methodKind == MethodKind.ABSTRACT)
+                                                    out.write("abstract ");
+                                                if (methodGenericKind == GenericKind.GENERIC)
+                                                    out.write("<MT> ");
+                                                out.write("void m" + (methodNum++) + "(int i1, long l2, float f3)");
+                                                if (methodKind == MethodKind.ABSTRACT || methodClassKind == ClassKind.INTERFACE)
+                                                    out.write(";\n");
+                                                else {
+                                                    out.write(" {");
+                                                    if (finalKind == FinalKind.USE_FINAL)
+                                                        out.write(" int i = fi1;");
+                                                    out.write(" }\n");
+                                                }
+                                                break;
+                                            case BRIDGE_METHOD:
+                                                if (methodGenericKind == GenericKind.GENERIC)
+                                                    break;
+                                                out.write(indent);
+                                                // methods Base.base_m1 and Base.base_m2 are declared for the
+                                                // benefit of bridge methods. They need to be implemented
+                                                // whether or not a final variable is used.
+                                                String methodName = (finalKind == FinalKind.NO_FINAL ? "base_m1" : "base_m2");
+                                                out.write("public String " + methodName + "(int i1)");
+                                                if (methodClassKind == ClassKind.INTERFACE)
+                                                    out.write(";\n");
+                                                else {
+                                                    out.write(" {");
+                                                    if (finalKind == FinalKind.USE_FINAL && haveFinal)
+                                                        out.write(" int i = fi1;");
+                                                    out.write(" return null; }\n");
+                                                }
+                                                break;
+                                            case STATIC_METHOD:
+                                                if (!allowStaticMethods)
+                                                    break;
+                                                if (finalKind == FinalKind.USE_FINAL && !haveFinal)
+                                                    break;
+                                                out.write(indent + "static ");
+                                                if (methodGenericKind == GenericKind.GENERIC)
+                                                    out.write("<MT> ");
+                                                out.write("void m" + (methodNum++) + "(int i1, long l2, float f3) {");
+                                                if (finalKind == FinalKind.USE_FINAL)
+                                                    out.write(" int i = fi1;");
+                                                out.write(" }\n");
+                                                break;
+                                        }
+
+                                    }
+                                }
+                            }
+                            if (nestedKind != NestedKind.NONE) {
+                                indent = indent.substring(0, indent.length() - 4);
+                                out.write(indent + "};\n");
+                            }
+                        }
+                        switch (nestedKind) {
+                            case METHOD_ANON: case METHOD_LOCAL:
+                            case INIT_ANON: case INIT_LOCAL:
+                                indent = indent.substring(0, indent.length() - 4);
+                                out.write(indent + "}\n\n");
+                        }
+                    }
+                }
+                out.write("}\n\n");
+            }
+        }
+        out.close();
+    }
+
+
+    void test(String testName, boolean expectNames, String... opts) throws Exception {
+        System.err.println("Test " + testName
+                + ": expectNames:" + expectNames
+                + " javacOpts:" + Arrays.asList(opts));
+
+        File outDir = new File(testName);
+        outDir.mkdirs();
+        compile(outDir, opts);
+
+        Context ctx = new Context();
+        JavacFileManager fm = new JavacFileManager(ctx, true, null);
+        fm.setLocation(StandardLocation.CLASS_PATH, Arrays.asList(outDir));
+        ClassReader cr = ClassReader.instance(ctx);
+        cr.saveParameterNames = true;
+        Names names = Names.instance(ctx);
+
+        Set<String> classes = getTopLevelClasses(outDir);
+        Deque<String> work = new LinkedList<String>(classes);
+        String classname;
+        while ((classname = work.poll()) != null) {
+            System.err.println("Checking class " + classname);
+            ClassSymbol sym = cr.enterClass(names.table.fromString(classname));
+            sym.complete();
+
+            if ((sym.flags() & Flags.INTERFACE) != 0 && !testInterfaces)
+                continue;
+
+            for (Scope.Entry e = sym.members_field.elems; e != null; e = e.sibling) {
+                System.err.println("Checking member " + e.sym);
+                switch (e.sym.kind) {
+                    case Kinds.TYP: {
+                        String name = e.sym.flatName().toString();
+                        if (!classes.contains(name)) {
+                            classes.add(name);
+                            work.add(name);
+                        }
+                        break;
+                    }
+                    case Kinds.MTH:
+                        verify((MethodSymbol) e.sym, expectNames);
+                        break;
+                }
+
+            }
+        }
+    }
+
+    void verify(MethodSymbol m, boolean expectNames) {
+        if ((m.flags() & Flags.SYNTHETIC) != 0 && !testSyntheticMethods)
+            return;
+
+        //System.err.println("verify: " + m.params());
+        int i = 1;
+        for (VarSymbol v: m.params()) {
+            String expectName;
+            if (expectNames)
+                expectName = getExpectedName(v, i);
+            else
+                expectName = "arg" + (i - 1);
+            checkEqual(expectName, v.name.toString());
+            i++;
+        }
+    }
+
+    String getExpectedName(VarSymbol v, int i) {
+        // special cases:
+        // synthetic method
+        if (((v.owner.owner.flags() & Flags.ENUM) != 0)
+                && v.owner.name.toString().equals("valueOf"))
+            return "name";
+        // interfaces don't have saved names
+        // -- no Code attribute for the LocalVariableTable attribute
+        if ((v.owner.owner.flags() & Flags.INTERFACE) != 0)
+            return "arg" + (i - 1);
+        // abstract methods don't have saved names
+        // -- no Code attribute for the LocalVariableTable attribute
+        if ((v.owner.flags() & Flags.ABSTRACT) != 0)
+            return "arg" + (i - 1);
+        // bridge methods use xN
+        if ((v.owner.flags() & Flags.BRIDGE) != 0)
+            return "x" + (i - 1);
+
+        // The rest of this method assumes the local conventions in the test program
+        Type t = v.type;
+        String s;
+        if (t.tag == TypeTags.CLASS)
+            s = ((ClassType) t).tsym.name.toString();
+        else
+            s = t.toString();
+        return String.valueOf(Character.toLowerCase(s.charAt(0))) + i;
+    }
+
+    void compile(File outDir, String... opts) throws Exception {
+        //File testSrc = new File(System.getProperty("test.src"), ".");
+        List<String> args = new ArrayList<String>();
+        args.add("-d");
+        args.add(outDir.getPath());
+        args.addAll(Arrays.asList(opts));
+        //args.add(new File(testSrc, "Test.java").getPath());
+        args.add("Test.java");
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        int rc = com.sun.tools.javac.Main.compile(args.toArray(new String[args.size()]), pw);
+        pw.close();
+        if (rc != 0) {
+            System.err.println(sw.toString());
+            throw new Exception("compilation failed unexpectedly");
+        }
+    }
+
+    Set<String> getTopLevelClasses(File outDir) {
+        Set<String> classes = new HashSet<String>();
+        for (String f: outDir.list()) {
+            if (f.endsWith(".class") && !f.contains("$"))
+                classes.add(f.replace(".class", ""));
+        }
+        return classes;
+    }
+
+    void checkEqual(String expect, String found) {
+        if (!expect.equals(found))
+            error("mismatch: expected:" + expect + " found:" + found);
+    }
+
+    void error(String msg) {
+        System.err.println(msg);
+        errors++;
+        throw new Error();
+    }
+
+    int errors;
+}
--- a/test/tools/javac/api/6440528/T6440528.java	Sun Oct 18 15:10:48 2009 -0700
+++ b/test/tools/javac/api/6440528/T6440528.java	Sat Oct 31 08:52:31 2009 -0700
@@ -59,9 +59,9 @@
     }
 
     private File getUnderlyingFile(Object o) throws Exception {
-        Field f = o.getClass().getDeclaredField("f");
-        f.setAccessible(true);
-        return (File)f.get(o);
+        Field file = o.getClass().getDeclaredField("file");
+        file.setAccessible(true);
+        return (File)file.get(o);
     }
 
     public static void main(String... args) throws Exception {
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/api/T6838467.java	Sat Oct 31 08:52:31 2009 -0700
@@ -0,0 +1,249 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/*
+ * @test
+ * @bug 6838467
+ * @summary JSR199 FileObjects don't obey general contract of equals.
+ */
+
+import java.io.*;
+import java.util.*;
+import java.util.zip.*;
+import javax.tools.*;
+import com.sun.tools.javac.file.JavacFileManager;
+import com.sun.tools.javac.util.Context;
+
+public class T6838467 {
+    boolean fileSystemIsCaseSignificant = !new File("a").equals(new File("A"));
+
+    enum FileKind {
+        DIR("dir"),
+        ZIP("zip"),
+        ZIPFILEINDEX("zip");
+        FileKind(String path) {
+            file = new File(path);
+        }
+        final File file;
+    };
+
+    enum CompareKind {
+        SAME {
+            File other(File f) { return f; }
+        },
+        ABSOLUTE {
+            File other(File f) { return f.getAbsoluteFile(); }
+        },
+        DIFFERENT {
+            File other(File f) { return new File("not_" + f.getPath()); }
+        },
+        CASEEQUIV {
+            File other(File f) { return new File(f.getPath().toUpperCase()); }
+        };
+        abstract File other(File f);
+    };
+
+    String[] paths = { "p/A.java", "p/B.java", "p/C.java" };
+
+    public static void main(String... args) throws Exception {
+        new T6838467().run();
+    }
+
+    void run() throws Exception {
+        // on Windows, verify file system is not case significant
+        if (System.getProperty("os.name").toLowerCase().startsWith("windows")
+                && fileSystemIsCaseSignificant) {
+            error("fileSystemIsCaseSignificant is set on Windows.");
+        }
+
+        // create a set of directories and zip files to compare
+        createTestDir(new File("dir"), paths);
+        createTestDir(new File("not_dir"), paths);
+        createTestZip(new File("zip"), paths);
+        createTestZip(new File("not_zip"), paths);
+        if (fileSystemIsCaseSignificant) {
+            createTestDir(new File("DIR"), paths);
+            createTestZip(new File("ZIP"), paths);
+        }
+
+        // test the various sorts of file objects that can be obtained from
+        // the file manager, and for various values that may or may not match.
+        for (FileKind fk: FileKind.values()) {
+            for (CompareKind ck: CompareKind.values()) {
+                test(fk, ck);
+            }
+        }
+
+        // verify that the various different types of file object were all
+        // tested
+        Set<String> expectClasses = new HashSet<String>(Arrays.asList(
+                "RegularFileObject", "ZipFileObject", "ZipFileIndexFileObject" ));
+        if (!foundClasses.equals(expectClasses)) {
+            error("expected fileobject classes not found\n"
+                    + "expected: " + expectClasses + "\n"
+                    + "found: " + foundClasses);
+        }
+
+        if (errors > 0)
+            throw new Exception(errors + " errors");
+    }
+
+    void test(FileKind fk, CompareKind ck) throws IOException {
+        File f1 = fk.file;
+        JavaFileManager fm1 = createFileManager(fk, f1);
+
+        File f2 = ck.other(fk.file);
+        JavaFileManager fm2 = createFileManager(fk, f2);
+
+        try {
+            // If the directories or zip files match, we expect "n" matches in
+            // the "n-squared" comparisons to come, where "n" is the number of
+            // entries in the the directories or zip files.
+            // If the directories or zip files don't themselves match,
+            // we obviously don't expect any of their contents to match either.
+            int expect = (f1.getAbsoluteFile().equals(f2.getAbsoluteFile()) ? paths.length : 0);
+
+            System.err.println("test " + (++count) + " " + fk + " " + ck + " " + f1 + " " + f2);
+            test(fm1, fm2, expect);
+
+        } finally {
+            fm1.close();
+            fm2.close();
+        }
+    }
+
+    // For a pair of file managers that may or may not have similar entries
+    // on the classpath, compare all files returned from one against all files
+    // returned from the other.  For each pair of files, verify that if they
+    // are equal, the hashcode is equal as well, and finally verify that the
+    // expected number of matches was found.
+    void test(JavaFileManager fm1, JavaFileManager fm2, int expectEqualCount) throws IOException {
+        boolean foundFiles1 = false;
+        boolean foundFiles2 = false;
+        int foundEqualCount = 0;
+        Set<JavaFileObject.Kind> kinds =  EnumSet.allOf(JavaFileObject.Kind.class);
+        for (FileObject fo1: fm1.list(StandardLocation.CLASS_PATH, "p", kinds, false)) {
+            foundFiles1 = true;
+            foundClasses.add(fo1.getClass().getSimpleName());
+            for (FileObject fo2: fm2.list(StandardLocation.CLASS_PATH, "p", kinds, false)) {
+                foundFiles2 = true;
+                foundClasses.add(fo1.getClass().getSimpleName());
+                System.err.println("compare " + fo1 + " " + fo2);
+                if (fo1.equals(fo2)) {
+                    foundEqualCount++;
+                    int hash1 = fo1.hashCode();
+                    int hash2 = fo2.hashCode();
+                    if (hash1 != hash2)
+                        error("hashCode error: " + fo1 + " [" + hash1 + "] "
+                                + fo2 + " [" + hash2 + "]");
+                }
+            }
+        }
+        if (!foundFiles1)
+            error("no files found for file manager 1");
+        if (!foundFiles2)
+            error("no files found for file manager 2");
+        // verify the expected number of matches were found
+        if (foundEqualCount != expectEqualCount)
+            error("expected matches not found: expected " + expectEqualCount + ", found " + foundEqualCount);
+    }
+
+    // create a file manager to test a FileKind, with a given directory
+    // or zip file placed on the classpath
+    JavaFileManager createFileManager(FileKind fk, File classpath) throws IOException {
+        StandardJavaFileManager fm = createFileManager(fk == FileKind.ZIP);
+        fm.setLocation(StandardLocation.CLASS_PATH, Arrays.asList(classpath));
+        return fm;
+    }
+
+    JavacFileManager createFileManager(boolean useJavaUtilZip) {
+        // javac should really not be using system properties like this
+        // -- it should really be using (hidden) options -- but until then
+        // take care to leave system properties as we find them, so as not
+        // to adversely affect other tests that might follow.
+        String prev = System.getProperty("useJavaUtilZip");
+        boolean resetProperties = false;
+        try {
+            if (useJavaUtilZip) {
+                System.setProperty("useJavaUtilZip", "true");
+                resetProperties = true;
+            } else if (System.getProperty("useJavaUtilZip") != null) {
+                System.getProperties().remove("useJavaUtilZip");
+                resetProperties = true;
+            }
+
+            Context c = new Context();
+            return new JavacFileManager(c, false, null);
+        } finally {
+            if (resetProperties) {
+                if (prev == null) {
+                    System.getProperties().remove("useJavaUtilZip");
+                } else {
+                    System.setProperty("useJavaUtilZip", prev);
+                }
+            }
+        }
+    }
+
+    // create a directory containing a given set of paths
+    void createTestDir(File dir, String[] paths) throws IOException {
+        for (String p: paths) {
+            File file = new File(dir, p);
+            file.getParentFile().mkdirs();
+            FileWriter out = new FileWriter(file);
+            try {
+                out.write(p);
+            } finally {
+                out.close();
+            }
+        }
+    }
+
+    // create a sip file containing a given set of entries
+    void createTestZip(File zip, String[] paths) throws IOException {
+        if (zip.getParentFile() != null)
+            zip.getParentFile().mkdirs();
+        ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zip));
+        try {
+            for (String p: paths) {
+                ZipEntry ze = new ZipEntry(p);
+                zos.putNextEntry(ze);
+                byte[] bytes = p.getBytes();
+                zos.write(bytes, 0, bytes.length);
+                zos.closeEntry();
+            }
+        } finally {
+            zos.close();
+        }
+    }
+
+    void error(String msg) {
+        System.err.println("Error: " + msg);
+        errors++;
+    }
+
+    int count;
+    int errors;
+    Set<String> foundClasses = new HashSet<String>();
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/literals/T6891079.java	Sat Oct 31 08:52:31 2009 -0700
@@ -0,0 +1,12 @@
+/* @test /nodynamiccopyright/
+ * @bug 6891079
+ * @summary Compiler allows invalid binary literals 0b and oBL
+ * @compile/fail/ref=T6891079.out -XDrawDiagnostics T6891079.java
+ */
+
+class Test {
+    int bi = 0B;
+    long bl = 0BL;
+    int xi = 0X;
+    long xl = 0XL;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/literals/T6891079.out	Sat Oct 31 08:52:31 2009 -0700
@@ -0,0 +1,7 @@
+T6891079.java:8:14: compiler.err.invalid.binary.number
+T6891079.java:9:15: compiler.err.invalid.binary.number
+T6891079.java:9:18: compiler.err.expected: token.identifier
+T6891079.java:10:14: compiler.err.invalid.hex.number
+T6891079.java:11:15: compiler.err.invalid.hex.number
+T6891079.java:11:18: compiler.err.expected: token.identifier
+6 errors
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javap/classfile/6888367/T6888367.java	Sat Oct 31 08:52:31 2009 -0700
@@ -0,0 +1,511 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import com.sun.tools.classfile.*;
+import com.sun.tools.classfile.Type.ArrayType;
+import com.sun.tools.classfile.Type.ClassSigType;
+import com.sun.tools.classfile.Type.ClassType;
+import com.sun.tools.classfile.Type.MethodType;
+import com.sun.tools.classfile.Type.SimpleType;
+import com.sun.tools.classfile.Type.TypeParamType;
+import com.sun.tools.classfile.Type.WildcardType;
+
+/*
+ * @test
+ * @bug 6888367
+ * @summary classfile library parses signature attributes incorrectly
+ */
+
+/*
+ * This test is a pretty detailed test both of javac signature generation and classfile
+ * signature parsing.  The first part of the test tests all the examples given in the
+ * second part of the test. Each example comes with one or two annotations, @Desc, @Sig,
+ * for the descriptor and signature of the annotated declaration.  Annotations are
+ * provided whenever the annotated item is expected to have a corresponding value.
+ * Each annotation has two argument values.  The first arg is the expected value of the
+ * descriptor/signature as found in the class file.  This value is mostly for documentation
+ * purposes in reading the test.  The second value is the rendering of the descriptor or
+ * signature using a custom Type visitor that explicitly includes an indication of the
+ * Type classes being used to represent the  descriptor/signature.  Thus we test
+ * that the descriptor/signature is being parsed into the expected type tree structure.
+ */
+public class T6888367 {
+
+    public static void main(String... args) throws Exception {
+        new T6888367().run();
+    }
+
+    public void run() throws Exception {
+        ClassFile cf = getClassFile("Test");
+
+        testFields(cf);
+        testMethods(cf);
+        testInnerClasses(cf); // recursive
+
+        if (errors > 0)
+            throw new Exception(errors + " errors found");
+    }
+
+    void testFields(ClassFile cf) throws Exception {
+        String cn = cf.getName();
+        ConstantPool cp = cf.constant_pool;
+        for (Field f: cf.fields) {
+            test("field " + cn + "." + f.getName(cp), f.descriptor, f.attributes, cp);
+        }
+    }
+
+    void testMethods(ClassFile cf) throws Exception {
+        String cn = cf.getName();
+        ConstantPool cp = cf.constant_pool;
+        for (Method m: cf.methods) {
+            test("method " + cn + "." + m.getName(cp), m.descriptor, m.attributes, cp);
+        }
+    }
+
+    void testInnerClasses(ClassFile cf) throws Exception {
+        ConstantPool cp = cf.constant_pool;
+        InnerClasses_attribute ic =
+                (InnerClasses_attribute) cf.attributes.get(Attribute.InnerClasses);
+        for (InnerClasses_attribute.Info info: ic.classes) {
+            String outerClassName = cp.getClassInfo(info.outer_class_info_index).getName();
+            if (!outerClassName.equals(cf.getName())) {
+                continue;
+            }
+            String innerClassName = cp.getClassInfo(info.inner_class_info_index).getName();
+            ClassFile icf = getClassFile(innerClassName);
+            test("class " + innerClassName, null, icf.attributes, icf.constant_pool);
+            testInnerClasses(icf);
+        }
+    }
+
+    void test(String name, Descriptor desc, Attributes attrs, ConstantPool cp)
+            throws Exception {
+        AnnotValues d = getDescValue(attrs, cp);
+        AnnotValues s = getSigValue(attrs, cp);
+        if (d == null && s == null) // not a test field or method if no @Desc or @Sig given
+            return;
+
+        System.err.println(name);
+
+        if (desc != null) {
+            System.err.println("    descriptor: " + desc.getValue(cp));
+            checkEqual(d.raw, desc.getValue(cp));
+            Type dt = new Signature(desc.index).getType(cp);
+            checkEqual(d.type, tp.print(dt));
+        }
+
+        Signature_attribute sa = (Signature_attribute) attrs.get(Attribute.Signature);
+        if (sa != null)
+            System.err.println("     signature: " + sa.getSignature(cp));
+
+        if (s != null || sa != null) {
+            if (s != null && sa != null) {
+                checkEqual(s.raw, sa.getSignature(cp));
+                Type st = new Signature(sa.signature_index).getType(cp);
+                checkEqual(s.type, tp.print(st));
+            } else if (s != null)
+                error("@Sig annotation found but not Signature attribute");
+            else
+                error("Signature attribute found but no @Sig annotation");
+        }
+
+        System.err.println();
+    }
+
+
+    ClassFile getClassFile(String name) throws IOException, ConstantPoolException {
+        URL url = getClass().getResource(name + ".class");
+        InputStream in = url.openStream();
+        try {
+            return ClassFile.read(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    AnnotValues getDescValue(Attributes attrs, ConstantPool cp) throws Exception {
+        return getAnnotValues(Desc.class.getName(), attrs, cp);
+    }
+
+    AnnotValues getSigValue(Attributes attrs, ConstantPool cp) throws Exception {
+        return getAnnotValues(Sig.class.getName(), attrs, cp);
+    }
+
+    static class AnnotValues {
+        AnnotValues(String raw, String type) {
+            this.raw = raw;
+            this.type = type;
+        }
+        final String raw;
+        final String type;
+    }
+
+    AnnotValues getAnnotValues(String annotName, Attributes attrs, ConstantPool cp)
+            throws Exception {
+        RuntimeInvisibleAnnotations_attribute annots =
+                (RuntimeInvisibleAnnotations_attribute)attrs.get(Attribute.RuntimeInvisibleAnnotations);
+        if (annots != null) {
+            for (Annotation a: annots.annotations) {
+                if (cp.getUTF8Value(a.type_index).equals("L" + annotName + ";")) {
+                    Annotation.Primitive_element_value pv0 =
+                            (Annotation.Primitive_element_value) a.element_value_pairs[0].value;
+                    Annotation.Primitive_element_value pv1 =
+                            (Annotation.Primitive_element_value) a.element_value_pairs[1].value;
+                    return new AnnotValues(
+                            cp.getUTF8Value(pv0.const_value_index),
+                            cp.getUTF8Value(pv1.const_value_index));
+                }
+            }
+        }
+        return null;
+
+    }
+
+    void checkEqual(String expect, String found) {
+        if (!(expect == null ? found == null : expect.equals(found))) {
+            System.err.println("expected: " + expect);
+            System.err.println("   found: " + found);
+            error("unexpected values found");
+        }
+    }
+
+    void error(String msg) {
+        System.err.println("error: " + msg);
+        errors++;
+    }
+
+    int errors;
+
+    TypePrinter tp = new TypePrinter();
+
+    class TypePrinter implements Type.Visitor<String,Void> {
+        String print(Type t) {
+            return t == null ? null : t.accept(this, null);
+        }
+        String print(String pre, List<? extends Type> ts, String post) {
+            if (ts == null)
+                return null;
+            StringBuilder sb = new StringBuilder();
+            sb.append(pre);
+            String sep = "";
+            for (Type t: ts) {
+                sb.append(sep);
+                sb.append(print(t));
+                sep = ",";
+            }
+            sb.append(post);
+            return sb.toString();
+        }
+
+        public String visitSimpleType(SimpleType type, Void p) {
+            return "S{" + type.name + "}";
+        }
+
+        public String visitArrayType(ArrayType type, Void p) {
+            return "A{" + print(type.elemType) + "}";
+        }
+
+        public String visitMethodType(MethodType type, Void p) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("M{");
+            if (type.typeParamTypes != null)
+                sb.append(print("<", type.typeParamTypes, ">"));
+            sb.append(print(type.returnType));
+            sb.append(print("(", type.paramTypes, ")"));
+            if (type.throwsTypes != null)
+                sb.append(print("", type.throwsTypes, ""));
+            sb.append("}");
+            return sb.toString();
+        }
+
+        public String visitClassSigType(ClassSigType type, Void p) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("CS{");
+            if (type.typeParamTypes != null)
+                sb.append(print("<", type.typeParamTypes, ">"));
+            sb.append(print(type.superclassType));
+            if (type.superinterfaceTypes != null)
+                sb.append(print("i(", type.superinterfaceTypes, ")"));
+            sb.append("}");
+            return sb.toString();
+        }
+
+        public String visitClassType(ClassType type, Void p) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("C{");
+            if (type.outerType != null) {
+                sb.append(print(type.outerType));
+                sb.append(".");
+            }
+            sb.append(type.name);
+            if (type.typeArgs != null)
+                sb.append(print("<", type.typeArgs, ">"));
+            sb.append("}");
+            return sb.toString();
+        }
+
+        public String visitTypeParamType(TypeParamType type, Void p) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("TA{");
+            sb.append(type.name);
+            if (type.classBound != null) {
+                sb.append(":c");
+                sb.append(print(type.classBound));
+            }
+            if (type.interfaceBounds != null)
+                sb.append(print(":i", type.interfaceBounds, ""));
+            sb.append("}");
+            return sb.toString();
+        }
+
+        public String visitWildcardType(WildcardType type, Void p) {
+            switch (type.kind) {
+                case UNBOUNDED:
+                    return "W{?}";
+                case EXTENDS:
+                    return "W{e," + print(type.boundType) + "}";
+                case SUPER:
+                    return "W{s," + print(type.boundType) + "}";
+                default:
+                    throw new AssertionError();
+            }
+        }
+
+    };
+}
+
+
+@interface Desc {
+    String d();
+    String t();
+}
+
+@interface Sig {
+    String s();
+    String t();
+}
+
+class Clss { }
+interface Intf { }
+class GenClss<T> { }
+
+class Test {
+    // fields
+
+    @Desc(d="Z", t="S{boolean}")
+    boolean z;
+
+    @Desc(d="B", t="S{byte}")
+    byte b;
+
+    @Desc(d="C", t="S{char}")
+    char c;
+
+    @Desc(d="D", t="S{double}")
+    double d;
+
+    @Desc(d="F", t="S{float}")
+    float f;
+
+    @Desc(d="I", t="S{int}")
+    int i;
+
+    @Desc(d="J", t="S{long}")
+    long l;
+
+    @Desc(d="S", t="S{short}")
+    short s;
+
+    @Desc(d="LClss;", t="C{Clss}")
+    Clss clss;
+
+    @Desc(d="LIntf;", t="C{Intf}")
+    Intf intf;
+
+    @Desc(d="[I", t="A{S{int}}")
+    int[] ai;
+
+    @Desc(d="[LClss;", t="A{C{Clss}}")
+    Clss[] aClss;
+
+    @Desc(d="LGenClss;", t="C{GenClss}")
+    @Sig(s="LGenClss<LClss;>;", t="C{GenClss<C{Clss}>}")
+    GenClss<Clss> genClass;
+
+    // methods, return types
+
+    @Desc(d="()V", t="M{S{void}()}")
+    void mv0() { }
+
+    @Desc(d="()I", t="M{S{int}()}")
+    int mi0() { return 0; }
+
+    @Desc(d="()LClss;", t="M{C{Clss}()}")
+    Clss mclss0() { return null; }
+
+    @Desc(d="()[I", t="M{A{S{int}}()}")
+    int[] mai0() { return null; }
+
+    @Desc(d="()[LClss;", t="M{A{C{Clss}}()}")
+    Clss[] maClss0() { return null; }
+
+    @Desc(d="()LGenClss;", t="M{C{GenClss}()}")
+    @Sig(s="()LGenClss<LClss;>;", t="M{C{GenClss<C{Clss}>}()}")
+    GenClss<Clss> mgenClss0() { return null; }
+
+    @Desc(d="()LGenClss;", t="M{C{GenClss}()}")
+    @Sig(s="()LGenClss<*>;", t="M{C{GenClss<W{?}>}()}")
+    GenClss<?> mgenClssW0() { return null; }
+
+    @Desc(d="()LGenClss;", t="M{C{GenClss}()}")
+    @Sig(s="()LGenClss<+LClss;>;", t="M{C{GenClss<W{e,C{Clss}}>}()}")
+    GenClss<? extends Clss> mgenClssWExtClss0() { return null; }
+
+    @Desc(d="()LGenClss;", t="M{C{GenClss}()}")
+    @Sig(s="()LGenClss<-LClss;>;", t="M{C{GenClss<W{s,C{Clss}}>}()}")
+    GenClss<? super Clss> mgenClssWSupClss0() { return null; }
+
+    @Desc(d="()Ljava/lang/Object;", t="M{C{java/lang/Object}()}")
+    @Sig(s="<T:Ljava/lang/Object;>()TT;", t="M{<TA{T:cC{java/lang/Object}}>S{T}()}")
+    <T> T mt0() { return null; }
+
+    @Desc(d="()LGenClss;", t="M{C{GenClss}()}")
+    @Sig(s="<T:Ljava/lang/Object;>()LGenClss<+TT;>;",
+        t="M{<TA{T:cC{java/lang/Object}}>C{GenClss<W{e,S{T}}>}()}")
+    <T> GenClss<? extends T> mgenClssWExtT0() { return null; }
+
+    @Desc(d="()LGenClss;", t="M{C{GenClss}()}")
+    @Sig(s="<T:Ljava/lang/Object;>()LGenClss<-TT;>;", t="M{<TA{T:cC{java/lang/Object}}>C{GenClss<W{s,S{T}}>}()}")
+    <T> GenClss<? super T> mgenClssWSupT0() { return null; }
+
+    // methods, arg types
+
+    @Desc(d="(I)V", t="M{S{void}(S{int})}")
+    void mi1(int arg) { }
+
+    @Desc(d="(LClss;)V", t="M{S{void}(C{Clss})}")
+    void mclss1(Clss arg) { }
+
+    @Desc(d="([I)V", t="M{S{void}(A{S{int}})}")
+    void mai1(int[] arg) { }
+
+    @Desc(d="([LClss;)V", t="M{S{void}(A{C{Clss}})}")
+    void maClss1(Clss[] arg) { }
+
+    @Desc(d="(LGenClss;)V", t="M{S{void}(C{GenClss})}")
+    @Sig(s="(LGenClss<LClss;>;)V", t="M{S{void}(C{GenClss<C{Clss}>})}")
+    void mgenClss1(GenClss<Clss> arg) { }
+
+    @Desc(d="(LGenClss;)V", t="M{S{void}(C{GenClss})}")
+    @Sig(s="(LGenClss<*>;)V", t="M{S{void}(C{GenClss<W{?}>})}")
+    void mgenClssW1(GenClss<?> arg) { }
+
+    @Desc(d="(LGenClss;)V", t="M{S{void}(C{GenClss})}")
+    @Sig(s="(LGenClss<+LClss;>;)V", t="M{S{void}(C{GenClss<W{e,C{Clss}}>})}")
+    void mgenClssWExtClss1(GenClss<? extends Clss> arg) { }
+
+    @Desc(d="(LGenClss;)V", t="M{S{void}(C{GenClss})}")
+    @Sig(s="(LGenClss<-LClss;>;)V", t="M{S{void}(C{GenClss<W{s,C{Clss}}>})}")
+    void mgenClssWSupClss1(GenClss<? super Clss> arg) { }
+
+    @Desc(d="(Ljava/lang/Object;)V", t="M{S{void}(C{java/lang/Object})}")
+    @Sig(s="<T:Ljava/lang/Object;>(TT;)V",
+        t="M{<TA{T:cC{java/lang/Object}}>S{void}(S{T})}")
+    <T> void mt1(T arg) { }
+
+    @Desc(d="(LGenClss;)V", t="M{S{void}(C{GenClss})}")
+    @Sig(s="<T:Ljava/lang/Object;>(LGenClss<+TT;>;)V",
+        t="M{<TA{T:cC{java/lang/Object}}>S{void}(C{GenClss<W{e,S{T}}>})}")
+    <T> void mgenClssWExtT1(GenClss<? extends T> arg) { }
+
+    @Desc(d="(LGenClss;)V", t="M{S{void}(C{GenClss})}")
+    @Sig(s="<T:Ljava/lang/Object;>(LGenClss<-TT;>;)V",
+        t="M{<TA{T:cC{java/lang/Object}}>S{void}(C{GenClss<W{s,S{T}}>})}")
+    <T> void mgenClssWSupT1(GenClss<? super T> arg) { }
+
+    // methods, throws
+
+    @Desc(d="()V", t="M{S{void}()}")
+    void m_E() throws Exception { }
+
+    @Desc(d="()V", t="M{S{void}()}")
+    @Sig(s="<T:Ljava/lang/Throwable;>()V^TT;",
+        t="M{<TA{T:cC{java/lang/Throwable}}>S{void}()S{T}}")
+    <T extends Throwable> void m_T() throws T { }
+
+    // inner classes
+
+    static class X {
+        // no sig
+        class P { }
+
+        @Sig(s="<TQ:Ljava/lang/Object;>LTest$X$P;",
+            t="CS{<TA{TQ:cC{java/lang/Object}}>C{Test$X$P}}")
+        class Q<TQ> extends P { }
+
+        @Sig(s="<TR:Ljava/lang/Object;>LTest$X$Q<TTR;>;",
+            t="CS{<TA{TR:cC{java/lang/Object}}>C{Test$X$Q<S{TR}>}}")
+        class R<TR> extends Q<TR> { }
+    }
+
+    @Sig(s="<TY:Ljava/lang/Object;>Ljava/lang/Object;",
+        t="CS{<TA{TY:cC{java/lang/Object}}>C{java/lang/Object}}")
+    static class Y<TY> {
+        // no sig
+        class P { }
+
+        @Sig(s="<TQ:Ljava/lang/Object;>LTest$Y<TTY;>.P;",
+            t="CS{<TA{TQ:cC{java/lang/Object}}>C{C{Test$Y<S{TY}>}.P}}")
+        class Q<TQ> extends P { }
+
+        @Sig(s="<TR:Ljava/lang/Object;>LTest$Y<TTY;>.Q<TTR;>;",
+            t="CS{<TA{TR:cC{java/lang/Object}}>C{C{Test$Y<S{TY}>}.Q<S{TR}>}}")
+        class R<TR> extends Q<TR> {
+            // no sig
+            class R1 { }
+
+            @Sig(s="<TR2:Ljava/lang/Object;>LTest$Y<TTY;>.R<TTR;>.R1;",
+                t="CS{<TA{TR2:cC{java/lang/Object}}>C{C{C{Test$Y<S{TY}>}.R<S{TR}>}.R1}}")
+            class R2<TR2> extends R1 { }
+        }
+
+        @Sig(s="LTest$Y<TTY;>.Q<TTY;>;", t="C{C{Test$Y<S{TY}>}.Q<S{TY}>}")
+        class S extends Q<TY> {
+            // no sig
+            class S1 { }
+
+            @Sig(s="<TS2:Ljava/lang/Object;>LTest$Y<TTY;>.S.S1;",
+                t="CS{<TA{TS2:cC{java/lang/Object}}>C{C{C{Test$Y<S{TY}>}.S}.S1}}")
+            class S2<TS2> extends S1 { }
+
+            @Sig(s="LTest$Y<TTY;>.S.S2<TTY;>;",
+                t="C{C{C{Test$Y<S{TY}>}.S}.S2<S{TY}>}")
+            class S3 extends S2<TY> { }
+        }
+    }
+}
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javap/classfile/T6887895.java	Sat Oct 31 08:52:31 2009 -0700
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/*
+ * @test
+ * @bug 6887895
+ * @summary CONSTANT_Class_info getBaseName does not handle arrays of primitives correctly
+ */
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import com.sun.tools.classfile.*;
+import com.sun.tools.classfile.ConstantPool.*;
+
+public class T6887895 {
+    public static void main(String[] args) throws Exception {
+        new T6887895().run();
+    }
+
+    void run() throws Exception {
+        Set<String> found = new TreeSet<String>();
+
+        ClassFile cf = getClassFile("T6887895$Test.class");
+        for (CPInfo cpInfo: cf.constant_pool.entries()) {
+            if (cpInfo instanceof CONSTANT_Class_info) {
+                CONSTANT_Class_info info = (CONSTANT_Class_info) cpInfo;
+                String name = info.getName();
+                String baseName = info.getBaseName();
+                System.out.println("found: " + name + " " + baseName);
+                if (baseName != null)
+                    found.add(baseName);
+            }
+        }
+
+        String[] expectNames = {
+            "java/lang/Object",
+            "java/lang/String",
+            "T6887895",
+            "T6887895$Test"
+        };
+
+        Set<String> expect = new TreeSet<String>(Arrays.asList(expectNames));
+        if (!found.equals(expect)) {
+            System.err.println("found: " + found);
+            System.err.println("expect: " + expect);
+            throw new Exception("unexpected values found");
+        }
+    }
+
+    ClassFile getClassFile(String name) throws IOException, ConstantPoolException {
+        URL url = getClass().getResource(name);
+        InputStream in = url.openStream();
+        try {
+            return ClassFile.read(in);
+        } finally {
+            in.close();
+        }
+    }
+
+    class Test {
+        void m() {
+            boolean[] az = new boolean[0];
+            boolean[][] aaz = new boolean[0][];
+            boolean[][][] aaaz = new boolean[0][][];
+
+            byte[] ab = new byte[0];
+            byte[][] aab = new byte[0][];
+            byte[][][] aaab = new byte[0][][];
+
+            char[] ac = new char[0];
+            char[][] aac = new char[0][];
+            char[][][] aaac = new char[0][][];
+
+            double[] ad = new double[0];
+            double[][] aad = new double[0][];
+            double[][][] aaad = new double[0][][];
+
+            float[] af = new float[0];
+            float[][] aaf = new float[0][];
+            float[][][] aaaf = new float[0][][];
+
+            int[] ai = new int[0];
+            int[][] aai = new int[0][];
+            int[][][] aaai = new int[0][][];
+
+            long[] al = new long[0];
+            long[][] aal = new long[0][];
+            long[][][] aaal = new long[0][][];
+
+            short[] as = new short[0];
+            short[][] aas = new short[0][];
+            short[][][] aaas = new short[0][][];
+
+            String[] aS = new String[0];
+            String[][] aaS = new String[0][];
+            String[][][] aaaS = new String[0][][];
+        }
+    }
+}
+