Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/make/build.properties	Thu Jan 10 09:56:09 2013 -0800
     1.2 +++ b/make/build.properties	Thu Jan 10 15:53:02 2013 -0800
     1.3 @@ -153,6 +153,7 @@
     1.4  javap.includes = \
     1.5          com/sun/tools/classfile/ \
     1.6          com/sun/tools/javap/ \
     1.7 +        com/sun/tools/jdeps/ \
     1.8          sun/tools/javap/
     1.9  
    1.10  javap.tests = \

     2.1 --- a/makefiles/BuildLangtools.gmk	Thu Jan 10 09:56:09 2013 -0800
     2.2 +++ b/makefiles/BuildLangtools.gmk	Thu Jan 10 15:53:02 2013 -0800
     2.3 @@ -75,6 +75,7 @@
     2.4  	printf "jdk=$(JDK_VERSION)\nfull=$(FULL_VERSION)\nrelease=$(RELEASE)\n" > $(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/javah/resources/version.properties
     2.5  	printf "jdk=$(JDK_VERSION)\nfull=$(FULL_VERSION)\nrelease=$(RELEASE)\n" > $(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/javap/resources/version.properties
     2.6  	printf "jdk=$(JDK_VERSION)\nfull=$(FULL_VERSION)\nrelease=$(RELEASE)\n" > $(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/javac/resources/version.properties
     2.7 +	printf "jdk=$(JDK_VERSION)\nfull=$(FULL_VERSION)\nrelease=$(RELEASE)\n" > $(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/jdeps/resources/version.properties
     2.8  	echo Compiling $(words $(PROPSOURCES) v1 v2 v3) properties into resource bundles
     2.9  	$(TOOL_COMPILEPROPS_CMD) $(PROPCMDLINE) \
    2.10  		-compile 	$(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/javah/resources/version.properties \
    2.11 @@ -85,6 +86,9 @@
    2.12  				java.util.ListResourceBundle \
    2.13  		-compile	$(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/javac/resources/version.properties \
    2.14  				$(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/javac/resources/version.java \
    2.15 +				java.util.ListResourceBundle \
    2.16 +		-compile	$(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/jdeps/resources/version.properties \
    2.17 +				$(LANGTOOLS_OUTPUTDIR)/gensrc/com/sun/tools/jdeps/resources/version.java \
    2.18  				java.util.ListResourceBundle
    2.19  	echo PROPS_ARE_CREATED=yes > $@
    2.20  

     3.1 --- a/src/share/classes/com/sun/javadoc/AnnotationDesc.java	Thu Jan 10 09:56:09 2013 -0800
     3.2 +++ b/src/share/classes/com/sun/javadoc/AnnotationDesc.java	Thu Jan 10 15:53:02 2013 -0800
     3.3 @@ -52,6 +52,12 @@
     3.4       */
     3.5      ElementValuePair[] elementValues();
     3.6  
     3.7 +    /**
     3.8 +     * Check for the synthesized bit on the annotation.
     3.9 +     *
    3.10 +     * @return true if the annotation is synthesized.
    3.11 +     */
    3.12 +    boolean isSynthesized();
    3.13  
    3.14      /**
    3.15       * Represents an association between an annotation type element

     4.1 --- a/src/share/classes/com/sun/tools/classfile/Attribute.java	Thu Jan 10 09:56:09 2013 -0800
     4.2 +++ b/src/share/classes/com/sun/tools/classfile/Attribute.java	Thu Jan 10 15:53:02 2013 -0800
     4.3 @@ -1,5 +1,5 @@
     4.4  /*
     4.5 - * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
     4.6 + * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
     4.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4.8   *
     4.9   * This code is free software; you can redistribute it and/or modify it
    4.10 @@ -51,6 +51,7 @@
    4.11      public static final String LineNumberTable          = "LineNumberTable";
    4.12      public static final String LocalVariableTable       = "LocalVariableTable";
    4.13      public static final String LocalVariableTypeTable   = "LocalVariableTypeTable";
    4.14 +    public static final String MethodParameters         = "MethodParameters";
    4.15      public static final String RuntimeVisibleAnnotations = "RuntimeVisibleAnnotations";
    4.16      public static final String RuntimeInvisibleAnnotations = "RuntimeInvisibleAnnotations";
    4.17      public static final String RuntimeVisibleParameterAnnotations = "RuntimeVisibleParameterAnnotations";
    4.18 @@ -113,6 +114,7 @@
    4.19              standardAttributes.put(LocalVariableTypeTable, LocalVariableTypeTable_attribute.class);
    4.20  
    4.21              if (!compat) { // old javap does not recognize recent attributes
    4.22 +                standardAttributes.put(MethodParameters, MethodParameters_attribute.class);
    4.23                  standardAttributes.put(CompilationID, CompilationID_attribute.class);
    4.24                  standardAttributes.put(RuntimeInvisibleAnnotations, RuntimeInvisibleAnnotations_attribute.class);
    4.25                  standardAttributes.put(RuntimeInvisibleParameterAnnotations, RuntimeInvisibleParameterAnnotations_attribute.class);
    4.26 @@ -171,6 +173,7 @@
    4.27          R visitLineNumberTable(LineNumberTable_attribute attr, P p);
    4.28          R visitLocalVariableTable(LocalVariableTable_attribute attr, P p);
    4.29          R visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, P p);
    4.30 +        R visitMethodParameters(MethodParameters_attribute attr, P p);
    4.31          R visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, P p);
    4.32          R visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, P p);
    4.33          R visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, P p);

     5.1 --- a/src/share/classes/com/sun/tools/classfile/ClassWriter.java	Thu Jan 10 09:56:09 2013 -0800
     5.2 +++ b/src/share/classes/com/sun/tools/classfile/ClassWriter.java	Thu Jan 10 15:53:02 2013 -0800
     5.3 @@ -1,6 +1,6 @@
     5.4  
     5.5  /*
     5.6 - * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
     5.7 + * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved.
     5.8   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     5.9   *
    5.10   * This code is free software; you can redistribute it and/or modify it
    5.11 @@ -479,6 +479,15 @@
    5.12              out.writeShort(entry.index);
    5.13          }
    5.14  
    5.15 +        public Void visitMethodParameters(MethodParameters_attribute attr, ClassOutputStream out) {
    5.16 +            out.writeByte(attr.method_parameter_table.length);
    5.17 +            for (MethodParameters_attribute.Entry e : attr.method_parameter_table) {
    5.18 +                out.writeShort(e.name_index);
    5.19 +                out.writeInt(e.flags);
    5.20 +            }
    5.21 +            return null;
    5.22 +        }
    5.23 +
    5.24          public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, ClassOutputStream out) {
    5.25              annotationWriter.write(attr.annotations, out);
    5.26              return null;

     6.1 --- a/src/share/classes/com/sun/tools/classfile/Dependencies.java	Thu Jan 10 09:56:09 2013 -0800
     6.2 +++ b/src/share/classes/com/sun/tools/classfile/Dependencies.java	Thu Jan 10 15:53:02 2013 -0800
     6.3 @@ -142,6 +142,15 @@
     6.4      }
     6.5  
     6.6      /**
     6.7 +     * Get a finder to do class dependency analysis.
     6.8 +     *
     6.9 +     * @return a Class dependency finder
    6.10 +     */
    6.11 +    public static Finder getClassDependencyFinder() {
    6.12 +        return new ClassDependencyFinder();
    6.13 +    }
    6.14 +
    6.15 +    /**
    6.16       * Get the finder used to locate the dependencies for a class.
    6.17       * @return the finder
    6.18       */
    6.19 @@ -246,8 +255,6 @@
    6.20          return results;
    6.21      }
    6.22  
    6.23 -
    6.24 -
    6.25      /**
    6.26       * Find the dependencies of a class, using the current
    6.27       * {@link Dependencies#getFinder finder} and
    6.28 @@ -306,38 +313,44 @@
    6.29       * A location identifying a class.
    6.30       */
    6.31      static class SimpleLocation implements Location {
    6.32 -        public SimpleLocation(String className) {
    6.33 -            this.className = className;
    6.34 +        public SimpleLocation(String name) {
    6.35 +            this.name = name;
    6.36 +            this.className = name.replace('/', '.').replace('$', '.');
    6.37          }
    6.38  
    6.39 -        /**
    6.40 -         * Get the name of the class being depended on. This name will be used to
    6.41 -         * locate the class file for transitive dependency analysis.
    6.42 -         * @return the name of the class being depended on
    6.43 -         */
    6.44 +        public String getName() {
    6.45 +            return name;
    6.46 +        }
    6.47 +
    6.48          public String getClassName() {
    6.49              return className;
    6.50          }
    6.51  
    6.52 +        public String getPackageName() {
    6.53 +            int i = name.lastIndexOf('/');
    6.54 +            return (i > 0) ? name.substring(0, i).replace('/', '.') : "";
    6.55 +        }
    6.56 +
    6.57          @Override
    6.58          public boolean equals(Object other) {
    6.59              if (this == other)
    6.60                  return true;
    6.61              if (!(other instanceof SimpleLocation))
    6.62                  return false;
    6.63 -            return (className.equals(((SimpleLocation) other).className));
    6.64 +            return (name.equals(((SimpleLocation) other).name));
    6.65          }
    6.66  
    6.67          @Override
    6.68          public int hashCode() {
    6.69 -            return className.hashCode();
    6.70 +            return name.hashCode();
    6.71          }
    6.72  
    6.73          @Override
    6.74          public String toString() {
    6.75 -            return className;
    6.76 +            return name;
    6.77          }
    6.78  
    6.79 +        private String name;
    6.80          private String className;
    6.81      }
    6.82  
    6.83 @@ -431,9 +444,7 @@
    6.84          }
    6.85  
    6.86          public boolean accepts(Dependency dependency) {
    6.87 -            String cn = dependency.getTarget().getClassName();
    6.88 -            int lastSep = cn.lastIndexOf("/");
    6.89 -            String pn = (lastSep == -1 ? "" : cn.substring(0, lastSep));
    6.90 +            String pn = dependency.getTarget().getPackageName();
    6.91              if (packageNames.contains(pn))
    6.92                  return true;
    6.93  
    6.94 @@ -451,8 +462,6 @@
    6.95          private final boolean matchSubpackages;
    6.96      }
    6.97  
    6.98 -
    6.99 -
   6.100      /**
   6.101       * This class identifies class names directly or indirectly in the constant pool.
   6.102       */
   6.103 @@ -462,6 +471,26 @@
   6.104              for (CPInfo cpInfo: classfile.constant_pool.entries()) {
   6.105                  v.scan(cpInfo);
   6.106              }
   6.107 +            try {
   6.108 +                v.addClass(classfile.super_class);
   6.109 +                v.addClasses(classfile.interfaces);
   6.110 +                v.scan(classfile.attributes);
   6.111 +
   6.112 +                for (Field f : classfile.fields) {
   6.113 +                    v.scan(f.descriptor, f.attributes);
   6.114 +                }
   6.115 +                for (Method m : classfile.methods) {
   6.116 +                    v.scan(m.descriptor, m.attributes);
   6.117 +                    Exceptions_attribute e =
   6.118 +                        (Exceptions_attribute)m.attributes.get(Attribute.Exceptions);
   6.119 +                    if (e != null) {
   6.120 +                        v.addClasses(e.exception_index_table);
   6.121 +                    }
   6.122 +                }
   6.123 +            } catch (ConstantPoolException e) {
   6.124 +                throw new ClassFileError(e);
   6.125 +            }
   6.126 +
   6.127              return v.deps;
   6.128          }
   6.129      }
   6.130 @@ -558,9 +587,7 @@
   6.131              void scan(Descriptor d, Attributes attrs) {
   6.132                  try {
   6.133                      scan(new Signature(d.index).getType(constant_pool));
   6.134 -                    Signature_attribute sa = (Signature_attribute) attrs.get(Attribute.Signature);
   6.135 -                    if (sa != null)
   6.136 -                        scan(new Signature(sa.signature_index).getType(constant_pool));
   6.137 +                    scan(attrs);
   6.138                  } catch (ConstantPoolException e) {
   6.139                      throw new ClassFileError(e);
   6.140                  }
   6.141 @@ -574,6 +601,43 @@
   6.142                  t.accept(this, null);
   6.143              }
   6.144  
   6.145 +            void scan(Attributes attrs) {
   6.146 +                try {
   6.147 +                    Signature_attribute sa = (Signature_attribute)attrs.get(Attribute.Signature);
   6.148 +                    if (sa != null)
   6.149 +                        scan(sa.getParsedSignature().getType(constant_pool));
   6.150 +
   6.151 +                    scan((RuntimeVisibleAnnotations_attribute)
   6.152 +                            attrs.get(Attribute.RuntimeVisibleAnnotations));
   6.153 +                    scan((RuntimeVisibleParameterAnnotations_attribute)
   6.154 +                            attrs.get(Attribute.RuntimeVisibleParameterAnnotations));
   6.155 +                } catch (ConstantPoolException e) {
   6.156 +                    throw new ClassFileError(e);
   6.157 +                }
   6.158 +            }
   6.159 +
   6.160 +            private void scan(RuntimeAnnotations_attribute attr) throws ConstantPoolException {
   6.161 +                if (attr == null) {
   6.162 +                    return;
   6.163 +                }
   6.164 +                for (int i = 0; i < attr.annotations.length; i++) {
   6.165 +                    int index = attr.annotations[i].type_index;
   6.166 +                    scan(new Signature(index).getType(constant_pool));
   6.167 +                }
   6.168 +            }
   6.169 +
   6.170 +            private void scan(RuntimeParameterAnnotations_attribute attr) throws ConstantPoolException {
   6.171 +                if (attr == null) {
   6.172 +                    return;
   6.173 +                }
   6.174 +                for (int param = 0; param < attr.parameter_annotations.length; param++) {
   6.175 +                    for (int i = 0; i < attr.parameter_annotations[param].length; i++) {
   6.176 +                        int index = attr.parameter_annotations[param][i].type_index;
   6.177 +                        scan(new Signature(index).getType(constant_pool));
   6.178 +                    }
   6.179 +                }
   6.180 +            }
   6.181 +
   6.182              void addClass(int index) throws ConstantPoolException {
   6.183                  if (index != 0) {
   6.184                      String name = constant_pool.getClassInfo(index).getBaseName();
   6.185 @@ -698,6 +762,7 @@
   6.186                  findDependencies(type.paramTypes);
   6.187                  findDependencies(type.returnType);
   6.188                  findDependencies(type.throwsTypes);
   6.189 +                findDependencies(type.typeParamTypes);
   6.190                  return null;
   6.191              }
   6.192  
   6.193 @@ -709,7 +774,7 @@
   6.194  
   6.195              public Void visitClassType(ClassType type, Void p) {
   6.196                  findDependencies(type.outerType);
   6.197 -                addDependency(type.name);
   6.198 +                addDependency(type.getBinaryName());
   6.199                  findDependencies(type.typeArgs);
   6.200                  return null;
   6.201              }

     7.1 --- a/src/share/classes/com/sun/tools/classfile/Dependency.java	Thu Jan 10 09:56:09 2013 -0800
     7.2 +++ b/src/share/classes/com/sun/tools/classfile/Dependency.java	Thu Jan 10 15:53:02 2013 -0800
     7.3 @@ -71,7 +71,19 @@
     7.4           * dependency analysis.
     7.5           * @return the name of the class containing the location.
     7.6           */
     7.7 +        String getName();
     7.8 +
     7.9 +        /**
    7.10 +         * Get the fully-qualified name of the class containing the location.
    7.11 +         * @return the fully-qualified name of the class containing the location.
    7.12 +         */
    7.13          String getClassName();
    7.14 +
    7.15 +        /**
    7.16 +         * Get the package name of the class containing the location.
    7.17 +         * @return the package name of the class containing the location.
    7.18 +         */
    7.19 +        String getPackageName();
    7.20      }
    7.21  
    7.22  

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/src/share/classes/com/sun/tools/classfile/MethodParameters_attribute.java	Thu Jan 10 15:53:02 2013 -0800
     8.3 @@ -0,0 +1,87 @@
     8.4 +/*
     8.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
     8.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     8.7 + *
     8.8 + * This code is free software; you can redistribute it and/or modify it
     8.9 + * under the terms of the GNU General Public License version 2 only, as
    8.10 + * published by the Free Software Foundation.  Oracle designates this
    8.11 + * particular file as subject to the "Classpath" exception as provided
    8.12 + * by Oracle in the LICENSE file that accompanied this code.
    8.13 + *
    8.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    8.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    8.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    8.17 + * version 2 for more details (a copy is included in the LICENSE file that
    8.18 + * accompanied this code).
    8.19 + *
    8.20 + * You should have received a copy of the GNU General Public License version
    8.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    8.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    8.23 + *
    8.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    8.25 + * or visit www.oracle.com if you need additional information or have any
    8.26 + * questions.
    8.27 + */
    8.28 +
    8.29 +package com.sun.tools.classfile;
    8.30 +
    8.31 +import java.io.IOException;
    8.32 +
    8.33 +/**
    8.34 + * See JVMS, section 4.8.13.
    8.35 + *
    8.36 + *  <p><b>This is NOT part of any supported API.
    8.37 + *  If you write code that depends on this, you do so at your own risk.
    8.38 + *  This code and its internal interfaces are subject to change or
    8.39 + *  deletion without notice.</b>
    8.40 + */
    8.41 +public class MethodParameters_attribute extends Attribute {
    8.42 +
    8.43 +    public final int method_parameter_table_length;
    8.44 +    public final Entry[] method_parameter_table;
    8.45 +
    8.46 +    MethodParameters_attribute(ClassReader cr,
    8.47 +                              int name_index,
    8.48 +                              int length)
    8.49 +        throws IOException {
    8.50 +        super(name_index, length);
    8.51 +
    8.52 +        method_parameter_table_length = cr.readUnsignedByte();
    8.53 +        method_parameter_table = new Entry[method_parameter_table_length];
    8.54 +        for (int i = 0; i < method_parameter_table_length; i++)
    8.55 +            method_parameter_table[i] = new Entry(cr);
    8.56 +    }
    8.57 +
    8.58 +    public MethodParameters_attribute(ConstantPool constant_pool,
    8.59 +                                      Entry[] method_parameter_table)
    8.60 +        throws ConstantPoolException {
    8.61 +        this(constant_pool.getUTF8Index(Attribute.MethodParameters),
    8.62 +             method_parameter_table);
    8.63 +    }
    8.64 +
    8.65 +    public MethodParameters_attribute(int name_index,
    8.66 +                                      Entry[] method_parameter_table) {
    8.67 +        super(name_index, 1 + method_parameter_table.length * Entry.length());
    8.68 +        this.method_parameter_table_length = method_parameter_table.length;
    8.69 +        this.method_parameter_table = method_parameter_table;
    8.70 +    }
    8.71 +
    8.72 +    public <R, D> R accept(Visitor<R, D> visitor, D data) {
    8.73 +        return visitor.visitMethodParameters(this, data);
    8.74 +    }
    8.75 +
    8.76 +    public static class Entry {
    8.77 +        Entry(ClassReader cr) throws IOException {
    8.78 +            name_index = cr.readUnsignedShort();
    8.79 +            flags = cr.readInt();
    8.80 +        }
    8.81 +
    8.82 +        public static int length() {
    8.83 +            return 6;
    8.84 +        }
    8.85 +
    8.86 +        public final int name_index;
    8.87 +        public final int flags;
    8.88 +    }
    8.89 +
    8.90 +}

     9.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/AbstractMemberWriter.java	Thu Jan 10 09:56:09 2013 -0800
     9.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/AbstractMemberWriter.java	Thu Jan 10 15:53:02 2013 -0800
     9.3 @@ -321,7 +321,8 @@
     9.4              code.addContent(" ");
     9.5          }
     9.6          if (member.isMethod()) {
     9.7 -            if (((MethodDoc)member).isAbstract()) {
     9.8 +            if (!(member.containingClass().isInterface()) &&
     9.9 +                    ((MethodDoc)member).isAbstract()) {
    9.10                  code.addContent("abstract ");
    9.11              }
    9.12              // This check for isDefault() and the default modifier needs to be
    9.13 @@ -329,7 +330,7 @@
    9.14              // method summary section. Once the default modifier is added
    9.15              // to the Modifier list on DocEnv and once it is updated to use the
    9.16              // javax.lang.model.element.Modifier, we will need to remove this.
    9.17 -            else if (((MethodDoc)member).isDefault()) {
    9.18 +            if (((MethodDoc)member).isDefault()) {
    9.19                  code.addContent("default ");
    9.20              }
    9.21          }
    9.22 @@ -561,11 +562,14 @@
    9.23          if (member instanceof MethodDoc && !member.isAnnotationTypeElement()) {
    9.24              int methodType = (member.isStatic()) ? MethodTypes.STATIC.value() :
    9.25                      MethodTypes.INSTANCE.value();
    9.26 -            methodType = (classdoc.isInterface() || ((MethodDoc)member).isAbstract()) ?
    9.27 -                    methodType | MethodTypes.ABSTRACT.value() :
    9.28 -                    methodType | MethodTypes.CONCRETE.value();
    9.29 -            if (((MethodDoc)member).isDefault()) {
    9.30 -                methodType = methodType | MethodTypes.DEFAULT.value();
    9.31 +            if (member.containingClass().isInterface()) {
    9.32 +                methodType = (((MethodDoc) member).isAbstract())
    9.33 +                        ? methodType | MethodTypes.ABSTRACT.value()
    9.34 +                        : methodType | MethodTypes.DEFAULT.value();
    9.35 +            } else {
    9.36 +                methodType = (((MethodDoc) member).isAbstract())
    9.37 +                        ? methodType | MethodTypes.ABSTRACT.value()
    9.38 +                        : methodType | MethodTypes.CONCRETE.value();
    9.39              }
    9.40              if (Util.isDeprecated(member) || Util.isDeprecated(classdoc)) {
    9.41                  methodType = methodType | MethodTypes.DEPRECATED.value();

    10.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java	Thu Jan 10 09:56:09 2013 -0800
    10.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java	Thu Jan 10 15:53:02 2013 -0800
    10.3 @@ -90,6 +90,16 @@
    10.4      protected boolean printedAnnotationHeading = false;
    10.5  
    10.6      /**
    10.7 +     * To check whether the repeated annotations is documented or not.
    10.8 +     */
    10.9 +    private boolean isAnnotationDocumented = false;
   10.10 +
   10.11 +    /**
   10.12 +     * To check whether the container annotations is documented or not.
   10.13 +     */
   10.14 +    private boolean isContainerDocumented = false;
   10.15 +
   10.16 +    /**
   10.17       * Constructor to construct the HtmlStandardWriter object.
   10.18       *
   10.19       * @param path File to be generated.
   10.20 @@ -1793,50 +1803,66 @@
   10.21          StringBuilder annotation;
   10.22          for (int i = 0; i < descList.length; i++) {
   10.23              AnnotationTypeDoc annotationDoc = descList[i].annotationType();
   10.24 -            if (! Util.isDocumentedAnnotation(annotationDoc)){
   10.25 +            // If an annotation is not documented, do not add it to the list. If
   10.26 +            // the annotation is of a repeatable type, and if it is not documented
   10.27 +            // and also if its container annotation is not documented, do not add it
   10.28 +            // to the list. If an annotation of a repeatable type is not documented
   10.29 +            // but its container is documented, it will be added to the list.
   10.30 +            if (! Util.isDocumentedAnnotation(annotationDoc) &&
   10.31 +                    (!isAnnotationDocumented && !isContainerDocumented)) {
   10.32                  continue;
   10.33              }
   10.34              annotation = new StringBuilder();
   10.35 +            isAnnotationDocumented = false;
   10.36              LinkInfoImpl linkInfo = new LinkInfoImpl(configuration,
   10.37                  LinkInfoImpl.CONTEXT_ANNOTATION, annotationDoc);
   10.38 -            linkInfo.label = "@" + annotationDoc.name();
   10.39 -            annotation.append(getLink(linkInfo));
   10.40              AnnotationDesc.ElementValuePair[] pairs = descList[i].elementValues();
   10.41 -            if (pairs.length > 0) {
   10.42 -                annotation.append('(');
   10.43 +            // If the annotation is synthesized, do not print the container.
   10.44 +            if (descList[i].isSynthesized()) {
   10.45                  for (int j = 0; j < pairs.length; j++) {
   10.46 -                    if (j > 0) {
   10.47 -                        annotation.append(",");
   10.48 -                        if (linkBreak) {
   10.49 -                            annotation.append(DocletConstants.NL);
   10.50 -                            int spaces = annotationDoc.name().length() + 2;
   10.51 -                            for (int k = 0; k < (spaces + indent); k++) {
   10.52 -                                annotation.append(' ');
   10.53 -                            }
   10.54 -                        }
   10.55 -                    }
   10.56 -                    annotation.append(getDocLink(LinkInfoImpl.CONTEXT_ANNOTATION,
   10.57 -                        pairs[j].element(), pairs[j].element().name(), false));
   10.58 -                    annotation.append('=');
   10.59                      AnnotationValue annotationValue = pairs[j].value();
   10.60                      List<AnnotationValue> annotationTypeValues = new ArrayList<AnnotationValue>();
   10.61                      if (annotationValue.value() instanceof AnnotationValue[]) {
   10.62                          AnnotationValue[] annotationArray =
   10.63 -                            (AnnotationValue[]) annotationValue.value();
   10.64 -                        for (int k = 0; k < annotationArray.length; k++) {
   10.65 -                            annotationTypeValues.add(annotationArray[k]);
   10.66 -                        }
   10.67 +                                (AnnotationValue[]) annotationValue.value();
   10.68 +                        annotationTypeValues.addAll(Arrays.asList(annotationArray));
   10.69                      } else {
   10.70                          annotationTypeValues.add(annotationValue);
   10.71                      }
   10.72 -                    annotation.append(annotationTypeValues.size() == 1 ? "" : "{");
   10.73 -                    for (Iterator<AnnotationValue> iter = annotationTypeValues.iterator(); iter.hasNext(); ) {
   10.74 -                        annotation.append(annotationValueToString(iter.next()));
   10.75 -                        annotation.append(iter.hasNext() ? "," : "");
   10.76 +                    String sep = "";
   10.77 +                    for (AnnotationValue av : annotationTypeValues) {
   10.78 +                        annotation.append(sep);
   10.79 +                        annotation.append(annotationValueToString(av));
   10.80 +                        sep = " ";
   10.81                      }
   10.82 -                    annotation.append(annotationTypeValues.size() == 1 ? "" : "}");
   10.83                  }
   10.84 -                annotation.append(")");
   10.85 +            }
   10.86 +            else if (isAnnotationArray(pairs)) {
   10.87 +                // If the container has 1 or more value defined and if the
   10.88 +                // repeatable type annotation is not documented, do not print
   10.89 +                // the container.
   10.90 +                if (pairs.length == 1 && isAnnotationDocumented) {
   10.91 +                    AnnotationValue[] annotationArray =
   10.92 +                            (AnnotationValue[]) (pairs[0].value()).value();
   10.93 +                    List<AnnotationValue> annotationTypeValues = new ArrayList<AnnotationValue>();
   10.94 +                    annotationTypeValues.addAll(Arrays.asList(annotationArray));
   10.95 +                    String sep = "";
   10.96 +                    for (AnnotationValue av : annotationTypeValues) {
   10.97 +                        annotation.append(sep);
   10.98 +                        annotation.append(annotationValueToString(av));
   10.99 +                        sep = " ";
  10.100 +                    }
  10.101 +                }
  10.102 +                // If the container has 1 or more value defined and if the
  10.103 +                // repeatable type annotation is not documented, print the container.
  10.104 +                else {
  10.105 +                    addAnnotations(annotationDoc, linkInfo, annotation, pairs,
  10.106 +                        indent, false);
  10.107 +                }
  10.108 +            }
  10.109 +            else {
  10.110 +                addAnnotations(annotationDoc, linkInfo, annotation, pairs,
  10.111 +                        indent, linkBreak);
  10.112              }
  10.113              annotation.append(linkBreak ? DocletConstants.NL : "");
  10.114              results.add(annotation.toString());
  10.115 @@ -1844,6 +1870,91 @@
  10.116          return results;
  10.117      }
  10.118  
  10.119 +    /**
  10.120 +     * Add annotation to the annotation string.
  10.121 +     *
  10.122 +     * @param annotationDoc the annotation being documented
  10.123 +     * @param linkInfo the information about the link
  10.124 +     * @param annotation the annotation string to which the annotation will be added
  10.125 +     * @param pairs annotation type element and value pairs
  10.126 +     * @param indent the number of extra spaces to indent the annotations.
  10.127 +     * @param linkBreak if true, add new line between each member value
  10.128 +     */
  10.129 +    private void addAnnotations(AnnotationTypeDoc annotationDoc, LinkInfoImpl linkInfo,
  10.130 +            StringBuilder annotation, AnnotationDesc.ElementValuePair[] pairs,
  10.131 +            int indent, boolean linkBreak) {
  10.132 +        linkInfo.label = "@" + annotationDoc.name();
  10.133 +        annotation.append(getLink(linkInfo));
  10.134 +        if (pairs.length > 0) {
  10.135 +            annotation.append('(');
  10.136 +            for (int j = 0; j < pairs.length; j++) {
  10.137 +                if (j > 0) {
  10.138 +                    annotation.append(",");
  10.139 +                    if (linkBreak) {
  10.140 +                        annotation.append(DocletConstants.NL);
  10.141 +                        int spaces = annotationDoc.name().length() + 2;
  10.142 +                        for (int k = 0; k < (spaces + indent); k++) {
  10.143 +                            annotation.append(' ');
  10.144 +                        }
  10.145 +                    }
  10.146 +                }
  10.147 +                annotation.append(getDocLink(LinkInfoImpl.CONTEXT_ANNOTATION,
  10.148 +                        pairs[j].element(), pairs[j].element().name(), false));
  10.149 +                annotation.append('=');
  10.150 +                AnnotationValue annotationValue = pairs[j].value();
  10.151 +                List<AnnotationValue> annotationTypeValues = new ArrayList<AnnotationValue>();
  10.152 +                if (annotationValue.value() instanceof AnnotationValue[]) {
  10.153 +                    AnnotationValue[] annotationArray =
  10.154 +                            (AnnotationValue[]) annotationValue.value();
  10.155 +                    annotationTypeValues.addAll(Arrays.asList(annotationArray));
  10.156 +                } else {
  10.157 +                    annotationTypeValues.add(annotationValue);
  10.158 +                }
  10.159 +                annotation.append(annotationTypeValues.size() == 1 ? "" : "{");
  10.160 +                String sep = "";
  10.161 +                for (AnnotationValue av : annotationTypeValues) {
  10.162 +                    annotation.append(sep);
  10.163 +                    annotation.append(annotationValueToString(av));
  10.164 +                    sep = ",";
  10.165 +                }
  10.166 +                annotation.append(annotationTypeValues.size() == 1 ? "" : "}");
  10.167 +                isContainerDocumented = false;
  10.168 +            }
  10.169 +            annotation.append(")");
  10.170 +        }
  10.171 +    }
  10.172 +
  10.173 +    /**
  10.174 +     * Check if the annotation contains an array of annotation as a value. This
  10.175 +     * check is to verify if a repeatable type annotation is present or not.
  10.176 +     *
  10.177 +     * @param pairs annotation type element and value pairs
  10.178 +     *
  10.179 +     * @return true if the annotation contains an array of annotation as a value.
  10.180 +     */
  10.181 +    private boolean isAnnotationArray(AnnotationDesc.ElementValuePair[] pairs) {
  10.182 +        AnnotationValue annotationValue;
  10.183 +        for (int j = 0; j < pairs.length; j++) {
  10.184 +            annotationValue = pairs[j].value();
  10.185 +            if (annotationValue.value() instanceof AnnotationValue[]) {
  10.186 +                AnnotationValue[] annotationArray =
  10.187 +                        (AnnotationValue[]) annotationValue.value();
  10.188 +                if (annotationArray.length > 1) {
  10.189 +                    if (annotationArray[0].value() instanceof AnnotationDesc) {
  10.190 +                        AnnotationTypeDoc annotationDoc =
  10.191 +                                ((AnnotationDesc) annotationArray[0].value()).annotationType();
  10.192 +                        isContainerDocumented = true;
  10.193 +                        if (Util.isDocumentedAnnotation(annotationDoc)) {
  10.194 +                            isAnnotationDocumented = true;
  10.195 +                        }
  10.196 +                        return true;
  10.197 +                    }
  10.198 +                }
  10.199 +            }
  10.200 +        }
  10.201 +        return false;
  10.202 +    }
  10.203 +
  10.204      private String annotationValueToString(AnnotationValue annotationValue) {
  10.205          if (annotationValue.value() instanceof Type) {
  10.206              Type type = (Type) annotationValue.value();

    11.1 --- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Thu Jan 10 09:56:09 2013 -0800
    11.2 +++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Thu Jan 10 15:53:02 2013 -0800
    11.3 @@ -1283,8 +1283,9 @@
    11.4                  List<Name> paramNames = savedParameterNames;
    11.5                  savedParameterNames = null;
    11.6                  // discard the provided names if the list of names is the wrong size.
    11.7 -                if (paramNames == null || paramNames.size() != type.getParameterTypes().size())
    11.8 +                if (paramNames == null || paramNames.size() != type.getParameterTypes().size()) {
    11.9                      paramNames = List.nil();
   11.10 +                }
   11.11                  ListBuffer<VarSymbol> buf = new ListBuffer<VarSymbol>();
   11.12                  List<Name> remaining = paramNames;
   11.13                  // assert: remaining and paramNames are both empty or both

    12.1 --- a/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Thu Jan 10 09:56:09 2013 -0800
    12.2 +++ b/src/share/classes/com/sun/tools/javac/comp/DeferredAttr.java	Thu Jan 10 15:53:02 2013 -0800
    12.3 @@ -38,6 +38,7 @@
    12.4  import javax.tools.JavaFileObject;
    12.5  
    12.6  import java.util.ArrayList;
    12.7 +import java.util.EnumSet;
    12.8  import java.util.LinkedHashSet;
    12.9  import java.util.Map;
   12.10  import java.util.Queue;
   12.11 @@ -177,29 +178,19 @@
   12.12           * attribution round must follow one or more speculative rounds.
   12.13           */
   12.14          Type check(ResultInfo resultInfo) {
   12.15 +            return check(resultInfo, stuckVars(tree, env, resultInfo), basicCompleter);
   12.16 +        }
   12.17 +
   12.18 +        Type check(ResultInfo resultInfo, List<Type> stuckVars, DeferredTypeCompleter deferredTypeCompleter) {
   12.19              DeferredAttrContext deferredAttrContext =
   12.20                      resultInfo.checkContext.deferredAttrContext();
   12.21              Assert.check(deferredAttrContext != emptyDeferredAttrContext);
   12.22 -            List<Type> stuckVars = stuckVars(tree, env, resultInfo);
   12.23              if (stuckVars.nonEmpty()) {
   12.24                  deferredAttrContext.addDeferredAttrNode(this, resultInfo, stuckVars);
   12.25                  return Type.noType;
   12.26              } else {
   12.27                  try {
   12.28 -                    switch (deferredAttrContext.mode) {
   12.29 -                        case SPECULATIVE:
   12.30 -                            Assert.check(mode == null ||
   12.31 -                                    (mode == AttrMode.SPECULATIVE &&
   12.32 -                                    speculativeType(deferredAttrContext.msym, deferredAttrContext.phase).hasTag(NONE)));
   12.33 -                            JCTree speculativeTree = attribSpeculative(tree, env, resultInfo);
   12.34 -                            speculativeCache.put(deferredAttrContext.msym, speculativeTree, deferredAttrContext.phase);
   12.35 -                            return speculativeTree.type;
   12.36 -                        case CHECK:
   12.37 -                            Assert.check(mode == AttrMode.SPECULATIVE);
   12.38 -                            return attr.attribTree(tree, env, resultInfo);
   12.39 -                    }
   12.40 -                    Assert.error();
   12.41 -                    return null;
   12.42 +                    return deferredTypeCompleter.complete(this, resultInfo, deferredAttrContext);
   12.43                  } finally {
   12.44                      mode = deferredAttrContext.mode;
   12.45                  }
   12.46 @@ -208,6 +199,43 @@
   12.47      }
   12.48  
   12.49      /**
   12.50 +     * A completer for deferred types. Defines an entry point for type-checking
   12.51 +     * a deferred type.
   12.52 +     */
   12.53 +    interface DeferredTypeCompleter {
   12.54 +        /**
   12.55 +         * Entry point for type-checking a deferred type. Depending on the
   12.56 +         * circumstances, type-checking could amount to full attribution
   12.57 +         * or partial structural check (aka potential applicability).
   12.58 +         */
   12.59 +        Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext);
   12.60 +    }
   12.61 +
   12.62 +    /**
   12.63 +     * A basic completer for deferred types. This completer type-checks a deferred type
   12.64 +     * using attribution; depending on the attribution mode, this could be either standard
   12.65 +     * or speculative attribution.
   12.66 +     */
   12.67 +    DeferredTypeCompleter basicCompleter = new DeferredTypeCompleter() {
   12.68 +        public Type complete(DeferredType dt, ResultInfo resultInfo, DeferredAttrContext deferredAttrContext) {
   12.69 +            switch (deferredAttrContext.mode) {
   12.70 +                case SPECULATIVE:
   12.71 +                    Assert.check(dt.mode == null ||
   12.72 +                            (dt.mode == AttrMode.SPECULATIVE &&
   12.73 +                            dt.speculativeType(deferredAttrContext.msym, deferredAttrContext.phase).hasTag(NONE)));
   12.74 +                    JCTree speculativeTree = attribSpeculative(dt.tree, dt.env, resultInfo);
   12.75 +                    dt.speculativeCache.put(deferredAttrContext.msym, speculativeTree, deferredAttrContext.phase);
   12.76 +                    return speculativeTree.type;
   12.77 +                case CHECK:
   12.78 +                    Assert.check(dt.mode == AttrMode.SPECULATIVE);
   12.79 +                    return attr.attribTree(dt.tree, dt.env, resultInfo);
   12.80 +            }
   12.81 +            Assert.error();
   12.82 +            return null;
   12.83 +        }
   12.84 +    };
   12.85 +
   12.86 +    /**
   12.87       * The 'mode' in which the deferred type is to be type-checked
   12.88       */
   12.89      public enum AttrMode {
   12.90 @@ -498,10 +526,80 @@
   12.91                  if (resultInfo.pt.hasTag(NONE) || resultInfo.pt.isErroneous()) {
   12.92              return List.nil();
   12.93          } else {
   12.94 -            StuckChecker sc = new StuckChecker(resultInfo, env);
   12.95 +            return stuckVarsInternal(tree, resultInfo.pt, resultInfo.checkContext.inferenceContext());
   12.96 +        }
   12.97 +    }
   12.98 +    //where
   12.99 +        private List<Type> stuckVarsInternal(JCTree tree, Type pt, Infer.InferenceContext inferenceContext) {
  12.100 +            StuckChecker sc = new StuckChecker(pt, inferenceContext);
  12.101              sc.scan(tree);
  12.102              return List.from(sc.stuckVars);
  12.103          }
  12.104 +
  12.105 +    /**
  12.106 +     * A special tree scanner that would only visit portions of a given tree.
  12.107 +     * The set of nodes visited by the scanner can be customized at construction-time.
  12.108 +     */
  12.109 +    abstract static class FilterScanner extends TreeScanner {
  12.110 +
  12.111 +        final Filter<JCTree> treeFilter;
  12.112 +
  12.113 +        FilterScanner(final Set<JCTree.Tag> validTags) {
  12.114 +            this.treeFilter = new Filter<JCTree>() {
  12.115 +                public boolean accepts(JCTree t) {
  12.116 +                    return validTags.contains(t.getTag());
  12.117 +                }
  12.118 +            };
  12.119 +        }
  12.120 +
  12.121 +        @Override
  12.122 +        public void scan(JCTree tree) {
  12.123 +            if (tree != null) {
  12.124 +                if (treeFilter.accepts(tree)) {
  12.125 +                    super.scan(tree);
  12.126 +                } else {
  12.127 +                    skip(tree);
  12.128 +                }
  12.129 +            }
  12.130 +        }
  12.131 +
  12.132 +        /**
  12.133 +         * handler that is executed when a node has been discarded
  12.134 +         */
  12.135 +        abstract void skip(JCTree tree);
  12.136 +    }
  12.137 +
  12.138 +    /**
  12.139 +     * A tree scanner suitable for visiting the target-type dependent nodes of
  12.140 +     * a given argument expression.
  12.141 +     */
  12.142 +    static class PolyScanner extends FilterScanner {
  12.143 +
  12.144 +        PolyScanner() {
  12.145 +            super(EnumSet.of(CONDEXPR, PARENS, LAMBDA, REFERENCE));
  12.146 +        }
  12.147 +
  12.148 +        @Override
  12.149 +        void skip(JCTree tree) {
  12.150 +            //do nothing
  12.151 +        }
  12.152 +    }
  12.153 +
  12.154 +    /**
  12.155 +     * A tree scanner suitable for visiting the target-type dependent nodes nested
  12.156 +     * within a lambda expression body.
  12.157 +     */
  12.158 +    static class LambdaReturnScanner extends FilterScanner {
  12.159 +
  12.160 +        LambdaReturnScanner() {
  12.161 +            super(EnumSet.of(BLOCK, CASE, CATCH, DOLOOP, FOREACHLOOP,
  12.162 +                    FORLOOP, RETURN, SYNCHRONIZED, SWITCH, TRY, WHILELOOP));
  12.163 +        }
  12.164 +
  12.165 +        @Override
  12.166 +        void skip(JCTree tree) {
  12.167 +            //do nothing
  12.168 +        }
  12.169      }
  12.170  
  12.171      /**
  12.172 @@ -510,83 +608,32 @@
  12.173       * inferring types that make some of the nested expressions incompatible
  12.174       * with their corresponding instantiated target
  12.175       */
  12.176 -    class StuckChecker extends TreeScanner {
  12.177 +    class StuckChecker extends PolyScanner {
  12.178  
  12.179          Type pt;
  12.180 -        Filter<JCTree> treeFilter;
  12.181          Infer.InferenceContext inferenceContext;
  12.182          Set<Type> stuckVars = new LinkedHashSet<Type>();
  12.183 -        Env<AttrContext> env;
  12.184  
  12.185 -        final Filter<JCTree> argsFilter = new Filter<JCTree>() {
  12.186 -            public boolean accepts(JCTree t) {
  12.187 -                switch (t.getTag()) {
  12.188 -                    case CONDEXPR:
  12.189 -                    case LAMBDA:
  12.190 -                    case PARENS:
  12.191 -                    case REFERENCE:
  12.192 -                        return true;
  12.193 -                    default:
  12.194 -                        return false;
  12.195 -                }
  12.196 -            }
  12.197 -        };
  12.198 -
  12.199 -        final Filter<JCTree> lambdaBodyFilter = new Filter<JCTree>() {
  12.200 -            public boolean accepts(JCTree t) {
  12.201 -                switch (t.getTag()) {
  12.202 -                    case BLOCK: case CASE: case CATCH: case DOLOOP:
  12.203 -                    case FOREACHLOOP: case FORLOOP: case RETURN:
  12.204 -                    case SYNCHRONIZED: case SWITCH: case TRY: case WHILELOOP:
  12.205 -                        return true;
  12.206 -                    default:
  12.207 -                        return false;
  12.208 -                }
  12.209 -            }
  12.210 -        };
  12.211 -
  12.212 -        StuckChecker(ResultInfo resultInfo, Env<AttrContext> env) {
  12.213 -            this.pt = resultInfo.pt;
  12.214 -            this.inferenceContext = resultInfo.checkContext.inferenceContext();
  12.215 -            this.treeFilter = argsFilter;
  12.216 -            this.env = env;
  12.217 -        }
  12.218 -
  12.219 -        @Override
  12.220 -        public void scan(JCTree tree) {
  12.221 -            if (tree != null && treeFilter.accepts(tree)) {
  12.222 -                super.scan(tree);
  12.223 -            }
  12.224 +        StuckChecker(Type pt, Infer.InferenceContext inferenceContext) {
  12.225 +            this.pt = pt;
  12.226 +            this.inferenceContext = inferenceContext;
  12.227          }
  12.228  
  12.229          @Override
  12.230          public void visitLambda(JCLambda tree) {
  12.231 -            Type prevPt = pt;
  12.232 -            Filter<JCTree> prevFilter = treeFilter;
  12.233 -            try {
  12.234 -                if (inferenceContext.inferenceVars().contains(pt)) {
  12.235 -                    stuckVars.add(pt);
  12.236 -                }
  12.237 -                if (!types.isFunctionalInterface(pt.tsym)) {
  12.238 -                    return;
  12.239 -                }
  12.240 -                Type descType = types.findDescriptorType(pt);
  12.241 -                List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());
  12.242 -                if (!TreeInfo.isExplicitLambda(tree) &&
  12.243 -                        freeArgVars.nonEmpty()) {
  12.244 -                    stuckVars.addAll(freeArgVars);
  12.245 -                }
  12.246 -                pt = descType.getReturnType();
  12.247 -                if (tree.getBodyKind() == JCTree.JCLambda.BodyKind.EXPRESSION) {
  12.248 -                    scan(tree.getBody());
  12.249 -                } else {
  12.250 -                    treeFilter = lambdaBodyFilter;
  12.251 -                    super.visitLambda(tree);
  12.252 -                }
  12.253 -            } finally {
  12.254 -                pt = prevPt;
  12.255 -                treeFilter = prevFilter;
  12.256 +            if (inferenceContext.inferenceVars().contains(pt)) {
  12.257 +                stuckVars.add(pt);
  12.258              }
  12.259 +            if (!types.isFunctionalInterface(pt.tsym)) {
  12.260 +                return;
  12.261 +            }
  12.262 +            Type descType = types.findDescriptorType(pt);
  12.263 +            List<Type> freeArgVars = inferenceContext.freeVarsIn(descType.getParameterTypes());
  12.264 +            if (!TreeInfo.isExplicitLambda(tree) &&
  12.265 +                    freeArgVars.nonEmpty()) {
  12.266 +                stuckVars.addAll(freeArgVars);
  12.267 +            }
  12.268 +            scanLambdaBody(tree, descType.getReturnType());
  12.269          }
  12.270  
  12.271          @Override
  12.272 @@ -605,16 +652,19 @@
  12.273              stuckVars.addAll(freeArgVars);
  12.274          }
  12.275  
  12.276 -        @Override
  12.277 -        public void visitReturn(JCReturn tree) {
  12.278 -            Filter<JCTree> prevFilter = treeFilter;
  12.279 -            try {
  12.280 -                treeFilter = argsFilter;
  12.281 -                if (tree.expr != null) {
  12.282 -                    scan(tree.expr);
  12.283 -                }
  12.284 -            } finally {
  12.285 -                treeFilter = prevFilter;
  12.286 +        void scanLambdaBody(JCLambda lambda, final Type pt) {
  12.287 +            if (lambda.getBodyKind() == JCTree.JCLambda.BodyKind.EXPRESSION) {
  12.288 +                stuckVars.addAll(stuckVarsInternal(lambda.body, pt, inferenceContext));
  12.289 +            } else {
  12.290 +                LambdaReturnScanner lambdaScanner = new LambdaReturnScanner() {
  12.291 +                    @Override
  12.292 +                    public void visitReturn(JCReturn tree) {
  12.293 +                        if (tree.expr != null) {
  12.294 +                            stuckVars.addAll(stuckVarsInternal(tree.expr, pt, inferenceContext));
  12.295 +                        }
  12.296 +                    }
  12.297 +                };
  12.298 +                lambdaScanner.scan(lambda.body);
  12.299              }
  12.300          }
  12.301      }

    13.1 --- a/src/share/classes/com/sun/tools/javac/comp/Infer.java	Thu Jan 10 09:56:09 2013 -0800
    13.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Infer.java	Thu Jan 10 15:53:02 2013 -0800
    13.3 @@ -114,7 +114,7 @@
    13.4          }
    13.5      }
    13.6  
    13.7 -    private final InferenceException inferenceException;
    13.8 +    final InferenceException inferenceException;
    13.9  
   13.10  /***************************************************************************
   13.11   * Mini/Maximization of UndetVars
   13.12 @@ -271,15 +271,19 @@
   13.13                                    boolean allowBoxing,
   13.14                                    boolean useVarargs,
   13.15                                    Resolve.MethodResolutionContext resolveContext,
   13.16 +                                  Resolve.MethodCheck methodCheck,
   13.17                                    Warner warn) throws InferenceException {
   13.18          //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
   13.19          final InferenceContext inferenceContext = new InferenceContext(tvars, this, true);
   13.20          inferenceException.clear();
   13.21  
   13.22 +        DeferredAttr.DeferredAttrContext deferredAttrContext =
   13.23 +                resolveContext.deferredAttrContext(msym, inferenceContext);
   13.24 +
   13.25          try {
   13.26 -            rs.checkRawArgumentsAcceptable(env, msym, resolveContext.attrMode(), inferenceContext,
   13.27 -                    argtypes, mt.getParameterTypes(), allowBoxing, useVarargs, warn,
   13.28 -                    new InferenceCheckHandler(inferenceContext));
   13.29 +            methodCheck.argumentsAcceptable(env, deferredAttrContext, argtypes, mt.getParameterTypes(), warn);
   13.30 +
   13.31 +            deferredAttrContext.complete();
   13.32  
   13.33              // minimize as yet undetermined type variables
   13.34              for (Type t : inferenceContext.undetvars) {
   13.35 @@ -309,32 +313,6 @@
   13.36              inferenceContext.notifyChange(types);
   13.37          }
   13.38      }
   13.39 -    //where
   13.40 -
   13.41 -        /** inference check handler **/
   13.42 -        class InferenceCheckHandler implements Resolve.MethodCheckHandler {
   13.43 -
   13.44 -            InferenceContext inferenceContext;
   13.45 -
   13.46 -            public InferenceCheckHandler(InferenceContext inferenceContext) {
   13.47 -                this.inferenceContext = inferenceContext;
   13.48 -            }
   13.49 -
   13.50 -            public InapplicableMethodException arityMismatch() {
   13.51 -                return inferenceException.setMessage("infer.arg.length.mismatch", inferenceContext.inferenceVars());
   13.52 -            }
   13.53 -            public InapplicableMethodException argumentMismatch(boolean varargs, JCDiagnostic details) {
   13.54 -                String key = varargs ?
   13.55 -                        "infer.varargs.argument.mismatch" :
   13.56 -                        "infer.no.conforming.assignment.exists";
   13.57 -                return inferenceException.setMessage(key,
   13.58 -                        inferenceContext.inferenceVars(), details);
   13.59 -            }
   13.60 -            public InapplicableMethodException inaccessibleVarargs(Symbol location, Type expected) {
   13.61 -                return inferenceException.setMessage("inaccessible.varargs.type",
   13.62 -                        expected, Kinds.kindName(location), location);
   13.63 -            }
   13.64 -        }
   13.65  
   13.66      /** check that type parameters are within their bounds.
   13.67       */

    14.1 --- a/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Thu Jan 10 09:56:09 2013 -0800
    14.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Resolve.java	Thu Jan 10 15:53:02 2013 -0800
    14.3 @@ -506,6 +506,7 @@
    14.4                          List<Type> typeargtypes,
    14.5                          boolean allowBoxing,
    14.6                          boolean useVarargs,
    14.7 +                        MethodCheck methodCheck,
    14.8                          Warner warn) throws Infer.InferenceException {
    14.9  
   14.10          Type mt = types.memberType(site, m);
   14.11 @@ -558,10 +559,11 @@
   14.12                                      allowBoxing,
   14.13                                      useVarargs,
   14.14                                      currentResolutionContext,
   14.15 +                                    methodCheck,
   14.16                                      warn);
   14.17  
   14.18 -        checkRawArgumentsAcceptable(env, m, argtypes, mt.getParameterTypes(),
   14.19 -                                allowBoxing, useVarargs, warn);
   14.20 +        methodCheck.argumentsAcceptable(env, currentResolutionContext.deferredAttrContext(m, infer.emptyContext),
   14.21 +                                argtypes, mt.getParameterTypes(), warn);
   14.22          return mt;
   14.23      }
   14.24  
   14.25 @@ -578,7 +580,7 @@
   14.26              currentResolutionContext.attrMode = DeferredAttr.AttrMode.CHECK;
   14.27              MethodResolutionPhase step = currentResolutionContext.step = env.info.pendingResolutionPhase;
   14.28              return rawInstantiate(env, site, m, resultInfo, argtypes, typeargtypes,
   14.29 -                    step.isBoxingRequired(), step.isVarargsRequired(), warn);
   14.30 +                    step.isBoxingRequired(), step.isVarargsRequired(), resolveMethodCheck, warn);
   14.31          }
   14.32          finally {
   14.33              currentResolutionContext = prevContext;
   14.34 @@ -595,81 +597,66 @@
   14.35                       List<Type> typeargtypes,
   14.36                       boolean allowBoxing,
   14.37                       boolean useVarargs,
   14.38 +                     MethodCheck methodCheck,
   14.39                       Warner warn) {
   14.40          try {
   14.41              return rawInstantiate(env, site, m, resultInfo, argtypes, typeargtypes,
   14.42 -                                  allowBoxing, useVarargs, warn);
   14.43 +                                  allowBoxing, useVarargs, methodCheck, warn);
   14.44          } catch (InapplicableMethodException ex) {
   14.45              return null;
   14.46          }
   14.47      }
   14.48  
   14.49 -    /** Check if a parameter list accepts a list of args.
   14.50 +    /**
   14.51 +     * This interface defines an entry point that should be used to perform a
   14.52 +     * method check. A method check usually consist in determining as to whether
   14.53 +     * a set of types (actuals) is compatible with another set of types (formals).
   14.54 +     * Since the notion of compatibility can vary depending on the circumstances,
   14.55 +     * this interfaces allows to easily add new pluggable method check routines.
   14.56       */
   14.57 -    boolean argumentsAcceptable(Env<AttrContext> env,
   14.58 -                                Symbol msym,
   14.59 +    interface MethodCheck {
   14.60 +        /**
   14.61 +         * Main method check routine. A method check usually consist in determining
   14.62 +         * as to whether a set of types (actuals) is compatible with another set of
   14.63 +         * types (formals). If an incompatibility is found, an unchecked exception
   14.64 +         * is assumed to be thrown.
   14.65 +         */
   14.66 +        void argumentsAcceptable(Env<AttrContext> env,
   14.67 +                                DeferredAttrContext deferredAttrContext,
   14.68                                  List<Type> argtypes,
   14.69                                  List<Type> formals,
   14.70 -                                boolean allowBoxing,
   14.71 -                                boolean useVarargs,
   14.72 -                                Warner warn) {
   14.73 -        try {
   14.74 -            checkRawArgumentsAcceptable(env, msym, argtypes, formals, allowBoxing, useVarargs, warn);
   14.75 -            return true;
   14.76 -        } catch (InapplicableMethodException ex) {
   14.77 -            return false;
   14.78 +                                Warner warn);
   14.79 +    }
   14.80 +
   14.81 +    /**
   14.82 +     * Helper enum defining all method check diagnostics (used by resolveMethodCheck).
   14.83 +     */
   14.84 +    enum MethodCheckDiag {
   14.85 +        /**
   14.86 +         * Actuals and formals differs in length.
   14.87 +         */
   14.88 +        ARITY_MISMATCH("arg.length.mismatch", "infer.arg.length.mismatch"),
   14.89 +        /**
   14.90 +         * An actual is incompatible with a formal.
   14.91 +         */
   14.92 +        ARG_MISMATCH("no.conforming.assignment.exists", "infer.no.conforming.assignment.exists"),
   14.93 +        /**
   14.94 +         * An actual is incompatible with the varargs element type.
   14.95 +         */
   14.96 +        VARARG_MISMATCH("varargs.argument.mismatch", "infer.varargs.argument.mismatch"),
   14.97 +        /**
   14.98 +         * The varargs element type is inaccessible.
   14.99 +         */
  14.100 +        INACCESSIBLE_VARARGS("inaccessible.varargs.type", "inaccessible.varargs.type");
  14.101 +
  14.102 +        final String basicKey;
  14.103 +        final String inferKey;
  14.104 +
  14.105 +        MethodCheckDiag(String basicKey, String inferKey) {
  14.106 +            this.basicKey = basicKey;
  14.107 +            this.inferKey = inferKey;
  14.108          }
  14.109      }
  14.110 -    /**
  14.111 -     * A check handler is used by the main method applicability routine in order
  14.112 -     * to handle specific method applicability failures. It is assumed that a class
  14.113 -     * implementing this interface should throw exceptions that are a subtype of
  14.114 -     * InapplicableMethodException (see below). Such exception will terminate the
  14.115 -     * method applicability check and propagate important info outwards (for the
  14.116 -     * purpose of generating better diagnostics).
  14.117 -     */
  14.118 -    interface MethodCheckHandler {
  14.119 -        /* The number of actuals and formals differ */
  14.120 -        InapplicableMethodException arityMismatch();
  14.121 -        /* An actual argument type does not conform to the corresponding formal type */
  14.122 -        InapplicableMethodException argumentMismatch(boolean varargs, JCDiagnostic details);
  14.123 -        /* The element type of a varargs is not accessible in the current context */
  14.124 -        InapplicableMethodException inaccessibleVarargs(Symbol location, Type expected);
  14.125 -    }
  14.126 -
  14.127 -    /**
  14.128 -     * Basic method check handler used within Resolve - all methods end up
  14.129 -     * throwing InapplicableMethodException; a diagnostic fragment that describes
  14.130 -     * the cause as to why the method is not applicable is set on the exception
  14.131 -     * before it is thrown.
  14.132 -     */
  14.133 -    MethodCheckHandler resolveHandler = new MethodCheckHandler() {
  14.134 -            public InapplicableMethodException arityMismatch() {
  14.135 -                return inapplicableMethodException.setMessage("arg.length.mismatch");
  14.136 -            }
  14.137 -            public InapplicableMethodException argumentMismatch(boolean varargs, JCDiagnostic details) {
  14.138 -                String key = varargs ?
  14.139 -                        "varargs.argument.mismatch" :
  14.140 -                        "no.conforming.assignment.exists";
  14.141 -                return inapplicableMethodException.setMessage(key,
  14.142 -                        details);
  14.143 -            }
  14.144 -            public InapplicableMethodException inaccessibleVarargs(Symbol location, Type expected) {
  14.145 -                return inapplicableMethodException.setMessage("inaccessible.varargs.type",
  14.146 -                        expected, Kinds.kindName(location), location);
  14.147 -            }
  14.148 -    };
  14.149 -
  14.150 -    void checkRawArgumentsAcceptable(Env<AttrContext> env,
  14.151 -                                Symbol msym,
  14.152 -                                List<Type> argtypes,
  14.153 -                                List<Type> formals,
  14.154 -                                boolean allowBoxing,
  14.155 -                                boolean useVarargs,
  14.156 -                                Warner warn) {
  14.157 -        checkRawArgumentsAcceptable(env, msym, currentResolutionContext.attrMode(), infer.emptyContext, argtypes, formals,
  14.158 -                allowBoxing, useVarargs, warn, resolveHandler);
  14.159 -    }
  14.160  
  14.161      /**
  14.162       * Main method applicability routine. Given a list of actual types A,
  14.163 @@ -689,68 +676,94 @@
  14.164       *
  14.165       * A method check handler (see above) is used in order to report errors.
  14.166       */
  14.167 -    void checkRawArgumentsAcceptable(final Env<AttrContext> env,
  14.168 -                                Symbol msym,
  14.169 -                                DeferredAttr.AttrMode mode,
  14.170 -                                final Infer.InferenceContext inferenceContext,
  14.171 -                                List<Type> argtypes,
  14.172 -                                List<Type> formals,
  14.173 -                                boolean allowBoxing,
  14.174 -                                boolean useVarargs,
  14.175 -                                Warner warn,
  14.176 -                                final MethodCheckHandler handler) {
  14.177 -        Type varargsFormal = useVarargs ? formals.last() : null;
  14.178 -
  14.179 -        if (varargsFormal == null &&
  14.180 -                argtypes.size() != formals.size()) {
  14.181 -            throw handler.arityMismatch(); // not enough args
  14.182 -        }
  14.183 -
  14.184 -        DeferredAttr.DeferredAttrContext deferredAttrContext =
  14.185 -                deferredAttr.new DeferredAttrContext(mode, msym, currentResolutionContext.step, inferenceContext);
  14.186 -
  14.187 -        while (argtypes.nonEmpty() && formals.head != varargsFormal) {
  14.188 -            ResultInfo mresult = methodCheckResult(formals.head, allowBoxing, false, inferenceContext, deferredAttrContext, handler, warn);
  14.189 -            mresult.check(null, argtypes.head);
  14.190 -            argtypes = argtypes.tail;
  14.191 -            formals = formals.tail;
  14.192 -        }
  14.193 -
  14.194 -        if (formals.head != varargsFormal) {
  14.195 -            throw handler.arityMismatch(); // not enough args
  14.196 -        }
  14.197 -
  14.198 -        if (useVarargs) {
  14.199 -            //note: if applicability check is triggered by most specific test,
  14.200 -            //the last argument of a varargs is _not_ an array type (see JLS 15.12.2.5)
  14.201 -            final Type elt = types.elemtype(varargsFormal);
  14.202 -            ResultInfo mresult = methodCheckResult(elt, allowBoxing, true, inferenceContext, deferredAttrContext, handler, warn);
  14.203 -            while (argtypes.nonEmpty()) {
  14.204 +    MethodCheck resolveMethodCheck = new MethodCheck() {
  14.205 +        @Override
  14.206 +        public void argumentsAcceptable(final Env<AttrContext> env,
  14.207 +                                    DeferredAttrContext deferredAttrContext,
  14.208 +                                    List<Type> argtypes,
  14.209 +                                    List<Type> formals,
  14.210 +                                    Warner warn) {
  14.211 +            //should we expand formals?
  14.212 +            boolean useVarargs = deferredAttrContext.phase.isVarargsRequired();
  14.213 +
  14.214 +            //inference context used during this method check
  14.215 +            InferenceContext inferenceContext = deferredAttrContext.inferenceContext;
  14.216 +
  14.217 +            Type varargsFormal = useVarargs ? formals.last() : null;
  14.218 +
  14.219 +            if (varargsFormal == null &&
  14.220 +                    argtypes.size() != formals.size()) {
  14.221 +                report(MethodCheckDiag.ARITY_MISMATCH, inferenceContext); // not enough args
  14.222 +            }
  14.223 +
  14.224 +            while (argtypes.nonEmpty() && formals.head != varargsFormal) {
  14.225 +                ResultInfo mresult = methodCheckResult(false, formals.head, deferredAttrContext, warn);
  14.226                  mresult.check(null, argtypes.head);
  14.227                  argtypes = argtypes.tail;
  14.228 +                formals = formals.tail;
  14.229              }
  14.230 -            //check varargs element type accessibility
  14.231 -            varargsAccessible(env, elt, handler, inferenceContext);
  14.232 -        }
  14.233 -
  14.234 -        deferredAttrContext.complete();
  14.235 -    }
  14.236 -
  14.237 -    void varargsAccessible(final Env<AttrContext> env, final Type t, final Resolve.MethodCheckHandler handler, final InferenceContext inferenceContext) {
  14.238 -        if (inferenceContext.free(t)) {
  14.239 -            inferenceContext.addFreeTypeListener(List.of(t), new FreeTypeListener() {
  14.240 -                @Override
  14.241 -                public void typesInferred(InferenceContext inferenceContext) {
  14.242 -                    varargsAccessible(env, inferenceContext.asInstType(t, types), handler, inferenceContext);
  14.243 +
  14.244 +            if (formals.head != varargsFormal) {
  14.245 +                report(MethodCheckDiag.ARITY_MISMATCH, inferenceContext); // not enough args
  14.246 +            }
  14.247 +
  14.248 +            if (useVarargs) {
  14.249 +                //note: if applicability check is triggered by most specific test,
  14.250 +                //the last argument of a varargs is _not_ an array type (see JLS 15.12.2.5)
  14.251 +                final Type elt = types.elemtype(varargsFormal);
  14.252 +                ResultInfo mresult = methodCheckResult(true, elt, deferredAttrContext, warn);
  14.253 +                while (argtypes.nonEmpty()) {
  14.254 +                    mresult.check(null, argtypes.head);
  14.255 +                    argtypes = argtypes.tail;
  14.256                  }
  14.257 -            });
  14.258 -        } else {
  14.259 -            if (!isAccessible(env, t)) {
  14.260 -                Symbol location = env.enclClass.sym;
  14.261 -                throw handler.inaccessibleVarargs(location, t);
  14.262 +                //check varargs element type accessibility
  14.263 +                varargsAccessible(env, elt, inferenceContext);
  14.264              }
  14.265          }
  14.266 -    }
  14.267 +
  14.268 +        private void report(MethodCheckDiag diag, InferenceContext inferenceContext, Object... args) {
  14.269 +            boolean inferDiag = inferenceContext != infer.emptyContext;
  14.270 +            InapplicableMethodException ex = inferDiag ?
  14.271 +                    infer.inferenceException : inapplicableMethodException;
  14.272 +            if (inferDiag && (!diag.inferKey.equals(diag.basicKey))) {
  14.273 +                Object[] args2 = new Object[args.length + 1];
  14.274 +                System.arraycopy(args, 0, args2, 1, args.length);
  14.275 +                args2[0] = inferenceContext.inferenceVars();
  14.276 +                args = args2;
  14.277 +            }
  14.278 +            throw ex.setMessage(inferDiag ? diag.inferKey : diag.basicKey, args);
  14.279 +        }
  14.280 +
  14.281 +        private void varargsAccessible(final Env<AttrContext> env, final Type t, final InferenceContext inferenceContext) {
  14.282 +            if (inferenceContext.free(t)) {
  14.283 +                inferenceContext.addFreeTypeListener(List.of(t), new FreeTypeListener() {
  14.284 +                    @Override
  14.285 +                    public void typesInferred(InferenceContext inferenceContext) {
  14.286 +                        varargsAccessible(env, inferenceContext.asInstType(t, types), inferenceContext);
  14.287 +                    }
  14.288 +                });
  14.289 +            } else {
  14.290 +                if (!isAccessible(env, t)) {
  14.291 +                    Symbol location = env.enclClass.sym;
  14.292 +                    report(MethodCheckDiag.INACCESSIBLE_VARARGS, inferenceContext, t, Kinds.kindName(location), location);
  14.293 +                }
  14.294 +            }
  14.295 +        }
  14.296 +
  14.297 +        private ResultInfo methodCheckResult(final boolean varargsCheck, Type to,
  14.298 +                final DeferredAttr.DeferredAttrContext deferredAttrContext, Warner rsWarner) {
  14.299 +            CheckContext checkContext = new MethodCheckContext(!deferredAttrContext.phase.isBoxingRequired(), deferredAttrContext, rsWarner) {
  14.300 +                MethodCheckDiag methodDiag = varargsCheck ?
  14.301 +                                 MethodCheckDiag.VARARG_MISMATCH : MethodCheckDiag.ARG_MISMATCH;
  14.302 +
  14.303 +                @Override
  14.304 +                public void report(DiagnosticPosition pos, JCDiagnostic details) {
  14.305 +                    report(methodDiag, deferredAttrContext.inferenceContext, details);
  14.306 +                }
  14.307 +            };
  14.308 +            return new MethodResultInfo(to, checkContext);
  14.309 +        }
  14.310 +    };
  14.311  
  14.312      /**
  14.313       * Check context to be used during method applicability checks. A method check
  14.314 @@ -758,23 +771,24 @@
  14.315       */
  14.316      abstract class MethodCheckContext implements CheckContext {
  14.317  
  14.318 -        MethodCheckHandler handler;
  14.319 -        boolean useVarargs;
  14.320 -        Infer.InferenceContext inferenceContext;
  14.321 +        boolean strict;
  14.322          DeferredAttrContext deferredAttrContext;
  14.323          Warner rsWarner;
  14.324  
  14.325 -        public MethodCheckContext(MethodCheckHandler handler, boolean useVarargs,
  14.326 -                Infer.InferenceContext inferenceContext, DeferredAttrContext deferredAttrContext, Warner rsWarner) {
  14.327 -            this.handler = handler;
  14.328 -            this.useVarargs = useVarargs;
  14.329 -            this.inferenceContext = inferenceContext;
  14.330 -            this.deferredAttrContext = deferredAttrContext;
  14.331 -            this.rsWarner = rsWarner;
  14.332 +        public MethodCheckContext(boolean strict, DeferredAttrContext deferredAttrContext, Warner rsWarner) {
  14.333 +           this.strict = strict;
  14.334 +           this.deferredAttrContext = deferredAttrContext;
  14.335 +           this.rsWarner = rsWarner;
  14.336          }
  14.337  
  14.338 +        public boolean compatible(Type found, Type req, Warner warn) {
  14.339 +            return strict ?
  14.340 +                    types.isSubtypeUnchecked(found, deferredAttrContext.inferenceContext.asFree(req, types), warn) :
  14.341 +                    types.isConvertible(found, deferredAttrContext.inferenceContext.asFree(req, types), warn);
  14.342 +        }
  14.343 +
  14.344          public void report(DiagnosticPosition pos, JCDiagnostic details) {
  14.345 -            throw handler.argumentMismatch(useVarargs, details);
  14.346 +            throw inapplicableMethodException.setMessage(details);
  14.347          }
  14.348  
  14.349          public Warner checkWarner(DiagnosticPosition pos, Type found, Type req) {
  14.350 @@ -782,7 +796,7 @@
  14.351          }
  14.352  
  14.353          public InferenceContext inferenceContext() {
  14.354 -            return inferenceContext;
  14.355 +            return deferredAttrContext.inferenceContext;
  14.356          }
  14.357  
  14.358          public DeferredAttrContext deferredAttrContext() {
  14.359 @@ -791,56 +805,13 @@
  14.360      }
  14.361  
  14.362      /**
  14.363 -     * Subclass of method check context class that implements strict method conversion.
  14.364 -     * Strict method conversion checks compatibility between types using subtyping tests.
  14.365 +     * ResultInfo class to be used during method applicability checks. Check
  14.366 +     * for deferred types goes through special path.
  14.367       */
  14.368 -    class StrictMethodContext extends MethodCheckContext {
  14.369 -
  14.370 -        public StrictMethodContext(MethodCheckHandler handler, boolean useVarargs,
  14.371 -                Infer.InferenceContext inferenceContext, DeferredAttrContext deferredAttrContext, Warner rsWarner) {
  14.372 -            super(handler, useVarargs, inferenceContext, deferredAttrContext, rsWarner);
  14.373 -        }
  14.374 -
  14.375 -        public boolean compatible(Type found, Type req, Warner warn) {
  14.376 -            return types.isSubtypeUnchecked(found, inferenceContext.asFree(req, types), warn);
  14.377 -        }
  14.378 -    }
  14.379 -
  14.380 -    /**
  14.381 -     * Subclass of method check context class that implements loose method conversion.
  14.382 -     * Loose method conversion checks compatibility between types using method conversion tests.
  14.383 -     */
  14.384 -    class LooseMethodContext extends MethodCheckContext {
  14.385 -
  14.386 -        public LooseMethodContext(MethodCheckHandler handler, boolean useVarargs,
  14.387 -                Infer.InferenceContext inferenceContext, DeferredAttrContext deferredAttrContext, Warner rsWarner) {
  14.388 -            super(handler, useVarargs, inferenceContext, deferredAttrContext, rsWarner);
  14.389 -        }
  14.390 -
  14.391 -        public boolean compatible(Type found, Type req, Warner warn) {
  14.392 -            return types.isConvertible(found, inferenceContext.asFree(req, types), warn);
  14.393 -        }
  14.394 -    }
  14.395 -
  14.396 -    /**
  14.397 -     * Create a method check context to be used during method applicability check
  14.398 -     */
  14.399 -    ResultInfo methodCheckResult(Type to, boolean allowBoxing, boolean useVarargs,
  14.400 -            Infer.InferenceContext inferenceContext, DeferredAttr.DeferredAttrContext deferredAttrContext,
  14.401 -            MethodCheckHandler methodHandler, Warner rsWarner) {
  14.402 -        MethodCheckContext checkContext = allowBoxing ?
  14.403 -                new LooseMethodContext(methodHandler, useVarargs, inferenceContext, deferredAttrContext, rsWarner) :
  14.404 -                new StrictMethodContext(methodHandler, useVarargs, inferenceContext, deferredAttrContext, rsWarner);
  14.405 -        return new MethodResultInfo(to, checkContext, deferredAttrContext);
  14.406 -    }
  14.407 -
  14.408      class MethodResultInfo extends ResultInfo {
  14.409  
  14.410 -        DeferredAttr.DeferredAttrContext deferredAttrContext;
  14.411 -
  14.412 -        public MethodResultInfo(Type pt, CheckContext checkContext, DeferredAttr.DeferredAttrContext deferredAttrContext) {
  14.413 +        public MethodResultInfo(Type pt, CheckContext checkContext) {
  14.414              attr.super(VAL, pt, checkContext);
  14.415 -            this.deferredAttrContext = deferredAttrContext;
  14.416          }
  14.417  
  14.418          @Override
  14.419 @@ -855,12 +826,12 @@
  14.420  
  14.421          @Override
  14.422          protected MethodResultInfo dup(Type newPt) {
  14.423 -            return new MethodResultInfo(newPt, checkContext, deferredAttrContext);
  14.424 +            return new MethodResultInfo(newPt, checkContext);
  14.425          }
  14.426  
  14.427          @Override
  14.428          protected ResultInfo dup(CheckContext newContext) {
  14.429 -            return new MethodResultInfo(pt, newContext, deferredAttrContext);
  14.430 +            return new MethodResultInfo(pt, newContext);
  14.431          }
  14.432      }
  14.433  
  14.434 @@ -1071,7 +1042,7 @@
  14.435          Assert.check(sym.kind < AMBIGUOUS);
  14.436          try {
  14.437              Type mt = rawInstantiate(env, site, sym, null, argtypes, typeargtypes,
  14.438 -                               allowBoxing, useVarargs, types.noWarnings);
  14.439 +                               allowBoxing, useVarargs, resolveMethodCheck, types.noWarnings);
  14.440              if (!operator)
  14.441                  currentResolutionContext.addApplicableCandidate(sym, mt);
  14.442          } catch (InapplicableMethodException ex) {
  14.443 @@ -1151,52 +1122,20 @@
  14.444                  if (m1Abstract && !m2Abstract) return m2;
  14.445                  if (m2Abstract && !m1Abstract) return m1;
  14.446                  // both abstract or both concrete
  14.447 -                if (!m1Abstract && !m2Abstract)
  14.448 -                    return ambiguityError(m1, m2);
  14.449 -                // check that both signatures have the same erasure
  14.450 -                if (!types.isSameTypes(m1.erasure(types).getParameterTypes(),
  14.451 -                                       m2.erasure(types).getParameterTypes()))
  14.452 -                    return ambiguityError(m1, m2);
  14.453 -                // both abstract, neither overridden; merge throws clause and result type
  14.454 -                Type mst = mostSpecificReturnType(mt1, mt2);
  14.455 -                if (mst == null) {
  14.456 -                    // Theoretically, this can't happen, but it is possible
  14.457 -                    // due to error recovery or mixing incompatible class files
  14.458 -                    return ambiguityError(m1, m2);
  14.459 -                }
  14.460 -                Symbol mostSpecific = mst == mt1 ? m1 : m2;
  14.461 -                List<Type> allThrown = chk.intersect(mt1.getThrownTypes(), mt2.getThrownTypes());
  14.462 -                Type newSig = types.createMethodTypeWithThrown(mostSpecific.type, allThrown);
  14.463 -                MethodSymbol result = new MethodSymbol(
  14.464 -                        mostSpecific.flags(),
  14.465 -                        mostSpecific.name,
  14.466 -                        newSig,
  14.467 -                        mostSpecific.owner) {
  14.468 -                    @Override
  14.469 -                    public MethodSymbol implementation(TypeSymbol origin, Types types, boolean checkResult) {
  14.470 -                        if (origin == site.tsym)
  14.471 -                            return this;
  14.472 -                        else
  14.473 -                            return super.implementation(origin, types, checkResult);
  14.474 -                        }
  14.475 -                    };
  14.476 -                return result;
  14.477 +                return ambiguityError(m1, m2);
  14.478              }
  14.479              if (m1SignatureMoreSpecific) return m1;
  14.480              if (m2SignatureMoreSpecific) return m2;
  14.481              return ambiguityError(m1, m2);
  14.482          case AMBIGUOUS:
  14.483 +            //check if m1 is more specific than all ambiguous methods in m2
  14.484              AmbiguityError e = (AmbiguityError)m2;
  14.485 -            Symbol err1 = mostSpecific(argtypes, m1, e.sym, env, site, allowBoxing, useVarargs);
  14.486 -            Symbol err2 = mostSpecific(argtypes, m1, e.sym2, env, site, allowBoxing, useVarargs);
  14.487 -            if (err1 == err2) return err1;
  14.488 -            if (err1 == e.sym && err2 == e.sym2) return m2;
  14.489 -            if (err1 instanceof AmbiguityError &&
  14.490 -                err2 instanceof AmbiguityError &&
  14.491 -                ((AmbiguityError)err1).sym == ((AmbiguityError)err2).sym)
  14.492 -                return ambiguityError(m1, m2);
  14.493 -            else
  14.494 -                return ambiguityError(err1, err2);
  14.495 +            for (Symbol s : e.ambiguousSyms) {
  14.496 +                if (mostSpecific(argtypes, m1, s, env, site, allowBoxing, useVarargs) != m1) {
  14.497 +                    return e.addAmbiguousSymbol(m1);
  14.498 +                }
  14.499 +            }
  14.500 +            return m1;
  14.501          default:
  14.502              throw new AssertionError();
  14.503          }
  14.504 @@ -1274,12 +1213,19 @@
  14.505      }
  14.506      //where
  14.507      private boolean invocationMoreSpecific(Env<AttrContext> env, Type site, Symbol m2, List<Type> argtypes1, boolean allowBoxing, boolean useVarargs) {
  14.508 -        noteWarner.clear();
  14.509 -        Type mst = instantiate(env, site, m2, null,
  14.510 -                types.lowerBounds(argtypes1), null,
  14.511 -                allowBoxing, false, noteWarner);
  14.512 -        return mst != null &&
  14.513 -                !noteWarner.hasLint(Lint.LintCategory.UNCHECKED);
  14.514 +        MethodResolutionContext prevContext = currentResolutionContext;
  14.515 +        try {
  14.516 +            currentResolutionContext = new MethodResolutionContext();
  14.517 +            currentResolutionContext.step = allowBoxing ? BOX : BASIC;
  14.518 +            noteWarner.clear();
  14.519 +            Type mst = instantiate(env, site, m2, null,
  14.520 +                    types.lowerBounds(argtypes1), null,
  14.521 +                    allowBoxing, false, resolveMethodCheck, noteWarner);
  14.522 +            return mst != null &&
  14.523 +                    !noteWarner.hasLint(Lint.LintCategory.UNCHECKED);
  14.524 +        } finally {
  14.525 +            currentResolutionContext = prevContext;
  14.526 +        }
  14.527      }
  14.528      //where
  14.529      private Symbol adjustVarargs(Symbol to, Symbol from, boolean useVarargs) {
  14.530 @@ -2366,9 +2312,11 @@
  14.531          try {
  14.532              currentResolutionContext = new MethodResolutionContext();
  14.533              Name name = treeinfo.operatorName(optag);
  14.534 +            env.info.pendingResolutionPhase = currentResolutionContext.step = BASIC;
  14.535              Symbol sym = findMethod(env, syms.predefClass.type, name, argtypes,
  14.536                                      null, false, false, true);
  14.537              if (boxingEnabled && sym.kind >= WRONG_MTHS)
  14.538 +                env.info.pendingResolutionPhase = currentResolutionContext.step = BOX;
  14.539                  sym = findMethod(env, syms.predefClass.type, name, argtypes,
  14.540                                   null, true, false, true);
  14.541              return accessMethod(sym, pos, env.enclClass.sym.type, name,
  14.542 @@ -2524,6 +2472,10 @@
  14.543  
  14.544          @Override
  14.545          Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) {
  14.546 +            if (sym.kind == AMBIGUOUS) {
  14.547 +                AmbiguityError a_err = (AmbiguityError)sym;
  14.548 +                sym = a_err.mergeAbstracts(site);
  14.549 +            }
  14.550              if (sym.kind >= AMBIGUOUS) {
  14.551                  //if nothing is found return the 'first' error
  14.552                  sym = accessMethod(sym, pos, location, site, name, true, argtypes, typeargtypes);
  14.553 @@ -2579,6 +2531,10 @@
  14.554          abstract JCMemberReference.ReferenceKind referenceKind(Symbol sym);
  14.555  
  14.556          Symbol access(Env<AttrContext> env, DiagnosticPosition pos, Symbol location, Symbol sym) {
  14.557 +            if (sym.kind == AMBIGUOUS) {
  14.558 +                AmbiguityError a_err = (AmbiguityError)sym;
  14.559 +                sym = a_err.mergeAbstracts(site);
  14.560 +            }
  14.561              //skip error reporting
  14.562              return sym;
  14.563          }
  14.564 @@ -3014,9 +2970,7 @@
  14.565  
  14.566          @Override
  14.567          public Symbol access(Name name, TypeSymbol location) {
  14.568 -            if (sym.kind >= AMBIGUOUS)
  14.569 -                return ((ResolveError)sym).access(name, location);
  14.570 -            else if ((sym.kind & ERRONEOUS) == 0 && (sym.kind & TYP) != 0)
  14.571 +            if ((sym.kind & ERRONEOUS) == 0 && (sym.kind & TYP) != 0)
  14.572                  return types.createErrorType(name, location, sym.type).tsym;
  14.573              else
  14.574                  return sym;
  14.575 @@ -3338,14 +3292,32 @@
  14.576       * (either methods, constructors or operands) are ambiguous
  14.577       * given an actual arguments/type argument list.
  14.578       */
  14.579 -    class AmbiguityError extends InvalidSymbolError {
  14.580 +    class AmbiguityError extends ResolveError {
  14.581  
  14.582          /** The other maximally specific symbol */
  14.583 -        Symbol sym2;
  14.584 +        List<Symbol> ambiguousSyms = List.nil();
  14.585 +
  14.586 +        @Override
  14.587 +        public boolean exists() {
  14.588 +            return true;
  14.589 +        }
  14.590  
  14.591          AmbiguityError(Symbol sym1, Symbol sym2) {
  14.592 -            super(AMBIGUOUS, sym1, "ambiguity error");
  14.593 -            this.sym2 = sym2;
  14.594 +            super(AMBIGUOUS, "ambiguity error");
  14.595 +            ambiguousSyms = flatten(sym2).appendList(flatten(sym1));
  14.596 +        }
  14.597 +
  14.598 +        private List<Symbol> flatten(Symbol sym) {
  14.599 +            if (sym.kind == AMBIGUOUS) {
  14.600 +                return ((AmbiguityError)sym).ambiguousSyms;
  14.601 +            } else {
  14.602 +                return List.of(sym);
  14.603 +            }
  14.604 +        }
  14.605 +
  14.606 +        AmbiguityError addAmbiguousSymbol(Symbol s) {
  14.607 +            ambiguousSyms = ambiguousSyms.prepend(s);
  14.608 +            return this;
  14.609          }
  14.610  
  14.611          @Override
  14.612 @@ -3356,24 +3328,60 @@
  14.613                  Name name,
  14.614                  List<Type> argtypes,
  14.615                  List<Type> typeargtypes) {
  14.616 -            AmbiguityError pair = this;
  14.617 -            while (true) {
  14.618 -                if (pair.sym.kind == AMBIGUOUS)
  14.619 -                    pair = (AmbiguityError)pair.sym;
  14.620 -                else if (pair.sym2.kind == AMBIGUOUS)
  14.621 -                    pair = (AmbiguityError)pair.sym2;
  14.622 -                else break;
  14.623 -            }
  14.624 -            Name sname = pair.sym.name;
  14.625 -            if (sname == names.init) sname = pair.sym.owner.name;
  14.626 +            List<Symbol> diagSyms = ambiguousSyms.reverse();
  14.627 +            Symbol s1 = diagSyms.head;
  14.628 +            Symbol s2 = diagSyms.tail.head;
  14.629 +            Name sname = s1.name;
  14.630 +            if (sname == names.init) sname = s1.owner.name;
  14.631              return diags.create(dkind, log.currentSource(),
  14.632                        pos, "ref.ambiguous", sname,
  14.633 -                      kindName(pair.sym),
  14.634 -                      pair.sym,
  14.635 -                      pair.sym.location(site, types),
  14.636 -                      kindName(pair.sym2),
  14.637 -                      pair.sym2,
  14.638 -                      pair.sym2.location(site, types));
  14.639 +                      kindName(s1),
  14.640 +                      s1,
  14.641 +                      s1.location(site, types),
  14.642 +                      kindName(s2),
  14.643 +                      s2,
  14.644 +                      s2.location(site, types));
  14.645 +        }
  14.646 +
  14.647 +        /**
  14.648 +         * If multiple applicable methods are found during overload and none of them
  14.649 +         * is more specific than the others, attempt to merge their signatures.
  14.650 +         */
  14.651 +        Symbol mergeAbstracts(Type site) {
  14.652 +            Symbol fst = ambiguousSyms.last();
  14.653 +            Symbol res = fst;
  14.654 +            for (Symbol s : ambiguousSyms.reverse()) {
  14.655 +                Type mt1 = types.memberType(site, res);
  14.656 +                Type mt2 = types.memberType(site, s);
  14.657 +                if ((s.flags() & ABSTRACT) == 0 ||
  14.658 +                        !types.overrideEquivalent(mt1, mt2) ||
  14.659 +                        !types.isSameTypes(fst.erasure(types).getParameterTypes(),
  14.660 +                                       s.erasure(types).getParameterTypes())) {
  14.661 +                    //ambiguity cannot be resolved
  14.662 +                    return this;
  14.663 +                } else {
  14.664 +                    Type mst = mostSpecificReturnType(mt1, mt2);
  14.665 +                    if (mst == null) {
  14.666 +                        // Theoretically, this can't happen, but it is possible
  14.667 +                        // due to error recovery or mixing incompatible class files
  14.668 +                        return this;
  14.669 +                    }
  14.670 +                    Symbol mostSpecific = mst == mt1 ? res : s;
  14.671 +                    List<Type> allThrown = chk.intersect(mt1.getThrownTypes(), mt2.getThrownTypes());
  14.672 +                    Type newSig = types.createMethodTypeWithThrown(mostSpecific.type, allThrown);
  14.673 +                    res = new MethodSymbol(
  14.674 +                            mostSpecific.flags(),
  14.675 +                            mostSpecific.name,
  14.676 +                            newSig,
  14.677 +                            mostSpecific.owner);
  14.678 +                }
  14.679 +            }
  14.680 +            return res;
  14.681 +        }
  14.682 +
  14.683 +        @Override
  14.684 +        protected Symbol access(Name name, TypeSymbol location) {
  14.685 +            return ambiguousSyms.last();
  14.686          }
  14.687      }
  14.688  
  14.689 @@ -3450,6 +3458,10 @@
  14.690              candidates = candidates.append(c);
  14.691          }
  14.692  
  14.693 +        DeferredAttrContext deferredAttrContext(Symbol sym, InferenceContext inferenceContext) {
  14.694 +            return deferredAttr.new DeferredAttrContext(attrMode, sym, step, inferenceContext);
  14.695 +        }
  14.696 +
  14.697          /**
  14.698           * This class represents an overload resolution candidate. There are two
  14.699           * kinds of candidates: applicable methods and inapplicable methods;

    15.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Thu Jan 10 09:56:09 2013 -0800
    15.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Thu Jan 10 15:53:02 2013 -0800
    15.3 @@ -217,6 +217,13 @@
    15.4       */
    15.5      boolean haveParameterNameIndices;
    15.6  
    15.7 +    /** Set this to false every time we start reading a method
    15.8 +     * and are saving parameter names.  Set it to true when we see
    15.9 +     * MethodParameters, if it's set when we see a LocalVariableTable,
   15.10 +     * then we ignore the parameter names from the LVT.
   15.11 +     */
   15.12 +    boolean sawMethodParameters;
   15.13 +
   15.14      /**
   15.15       * The set of attribute names for which warnings have been generated for the current class
   15.16       */
   15.17 @@ -984,7 +991,7 @@
   15.18              new AttributeReader(names.LocalVariableTable, V45_3, CLASS_OR_MEMBER_ATTRIBUTE) {
   15.19                  protected void read(Symbol sym, int attrLen) {
   15.20                      int newbp = bp + attrLen;
   15.21 -                    if (saveParameterNames) {
   15.22 +                    if (saveParameterNames && !sawMethodParameters) {
   15.23                          // Pick up parameter names from the variable table.
   15.24                          // Parameter names are not explicitly identified as such,
   15.25                          // but all parameter name entries in the LocalVariableTable
   15.26 @@ -1017,6 +1024,25 @@
   15.27                  }
   15.28              },
   15.29  
   15.30 +            new AttributeReader(names.MethodParameters, V52, MEMBER_ATTRIBUTE) {
   15.31 +                protected void read(Symbol sym, int attrlen) {
   15.32 +                    int newbp = bp + attrlen;
   15.33 +                    if (saveParameterNames) {
   15.34 +                        sawMethodParameters = true;
   15.35 +                        int numEntries = nextByte();
   15.36 +                        parameterNameIndices = new int[numEntries];
   15.37 +                        haveParameterNameIndices = true;
   15.38 +                        for (int i = 0; i < numEntries; i++) {
   15.39 +                            int nameIndex = nextChar();
   15.40 +                            int flags = nextInt();
   15.41 +                            parameterNameIndices[i] = nameIndex;
   15.42 +                        }
   15.43 +                    }
   15.44 +                    bp = newbp;
   15.45 +                }
   15.46 +            },
   15.47 +
   15.48 +
   15.49              new AttributeReader(names.SourceFile, V45_3, CLASS_ATTRIBUTE) {
   15.50                  protected void read(Symbol sym, int attrLen) {
   15.51                      ClassSymbol c = (ClassSymbol) sym;
   15.52 @@ -1826,6 +1852,7 @@
   15.53          } else
   15.54              Arrays.fill(parameterNameIndices, 0);
   15.55          haveParameterNameIndices = false;
   15.56 +        sawMethodParameters = false;
   15.57      }
   15.58  
   15.59      /**
   15.60 @@ -1845,12 +1872,16 @@
   15.61          // if no names were found in the class file, there's nothing more to do
   15.62          if (!haveParameterNameIndices)
   15.63              return;
   15.64 -
   15.65 -        int firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
   15.66 -        // the code in readMethod may have skipped the first parameter when
   15.67 -        // setting up the MethodType. If so, we make a corresponding allowance
   15.68 -        // here for the position of the first parameter.  Note that this
   15.69 -        // assumes the skipped parameter has a width of 1 -- i.e. it is not
   15.70 +        // If we get parameter names from MethodParameters, then we
   15.71 +        // don't need to skip.
   15.72 +        int firstParam = 0;
   15.73 +        if (!sawMethodParameters) {
   15.74 +            firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
   15.75 +            // the code in readMethod may have skipped the first
   15.76 +            // parameter when setting up the MethodType. If so, we
   15.77 +            // make a corresponding allowance here for the position of
   15.78 +            // the first parameter.  Note that this assumes the
   15.79 +            // skipped parameter has a width of 1 -- i.e. it is not
   15.80          // a double width type (long or double.)
   15.81          if (sym.name == names.init && currentOwner.hasOuterInstance()) {
   15.82              // Sometimes anonymous classes don't have an outer
   15.83 @@ -1861,17 +1892,20 @@
   15.84          }
   15.85  
   15.86          if (sym.type != jvmType) {
   15.87 -            // reading the method attributes has caused the symbol's type to
   15.88 -            // be changed. (i.e. the Signature attribute.)  This may happen if
   15.89 -            // there are hidden (synthetic) parameters in the descriptor, but
   15.90 -            // not in the Signature.  The position of these hidden parameters
   15.91 -            // is unspecified; for now, assume they are at the beginning, and
   15.92 -            // so skip over them. The primary case for this is two hidden
   15.93 -            // parameters passed into Enum constructors.
   15.94 +                // reading the method attributes has caused the
   15.95 +                // symbol's type to be changed. (i.e. the Signature
   15.96 +                // attribute.)  This may happen if there are hidden
   15.97 +                // (synthetic) parameters in the descriptor, but not
   15.98 +                // in the Signature.  The position of these hidden
   15.99 +                // parameters is unspecified; for now, assume they are
  15.100 +                // at the beginning, and so skip over them. The
  15.101 +                // primary case for this is two hidden parameters
  15.102 +                // passed into Enum constructors.
  15.103              int skip = Code.width(jvmType.getParameterTypes())
  15.104                      - Code.width(sym.type.getParameterTypes());
  15.105              firstParam += skip;
  15.106          }
  15.107 +        }
  15.108          List<Name> paramNames = List.nil();
  15.109          int index = firstParam;
  15.110          for (Type t: sym.type.getParameterTypes()) {

    16.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Thu Jan 10 09:56:09 2013 -0800
    16.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Thu Jan 10 15:53:02 2013 -0800
    16.3 @@ -725,6 +725,28 @@
    16.4          return acount;
    16.5      }
    16.6  
    16.7 +    /**
    16.8 +     * Write method parameter names attribute.
    16.9 +     */
   16.10 +    int writeMethodParametersAttr(MethodSymbol m) {
   16.11 +        if (m.params != null && 0 != m.params.length()) {
   16.12 +            int attrIndex = writeAttr(names.MethodParameters);
   16.13 +            databuf.appendByte(m.params.length());
   16.14 +            for (VarSymbol s : m.params) {
   16.15 +                // TODO: expand to cover synthesized, once we figure out
   16.16 +                // how to represent that.
   16.17 +                final int flags = (int) s.flags() & (FINAL | SYNTHETIC);
   16.18 +                // output parameter info
   16.19 +                databuf.appendChar(pool.put(s.name));
   16.20 +                databuf.appendInt(flags);
   16.21 +            }
   16.22 +            endAttr(attrIndex);
   16.23 +            return 1;
   16.24 +        } else
   16.25 +            return 0;
   16.26 +    }
   16.27 +
   16.28 +
   16.29      /** Write method parameter annotations;
   16.30       *  return number of attributes written.
   16.31       */
   16.32 @@ -1034,6 +1056,8 @@
   16.33              endAttr(alenIdx);
   16.34              acount++;
   16.35          }
   16.36 +        if (options.isSet(PARAMETERS))
   16.37 +            acount += writeMethodParametersAttr(m);
   16.38          acount += writeMemberAttrs(m);
   16.39          acount += writeParameterAttrs(m);
   16.40          endAttrs(acountIdx, acount);

    17.1 --- a/src/share/classes/com/sun/tools/javac/main/Option.java	Thu Jan 10 09:56:09 2013 -0800
    17.2 +++ b/src/share/classes/com/sun/tools/javac/main/Option.java	Thu Jan 10 15:53:02 2013 -0800
    17.3 @@ -1,5 +1,5 @@
    17.4  /*
    17.5 - * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
    17.6 + * Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
    17.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    17.8   *
    17.9   * This code is free software; you can redistribute it and/or modify it
   17.10 @@ -176,6 +176,8 @@
   17.11  
   17.12      PROCESSORPATH("-processorpath", "opt.arg.path", "opt.processorpath", STANDARD, FILEMANAGER),
   17.13  
   17.14 +    PARAMETERS("-parameters","opt.parameters", STANDARD, BASIC),
   17.15 +
   17.16      D("-d", "opt.arg.directory", "opt.d", STANDARD, FILEMANAGER),
   17.17  
   17.18      S("-s", "opt.arg.directory", "opt.sourceDest", STANDARD, FILEMANAGER),
   17.19 @@ -309,7 +311,7 @@
   17.20  
   17.21      // This option exists only for the purpose of documenting itself.
   17.22      // It's actually implemented by the launcher.
   17.23 -    J("-J", "opt.arg.flag", "opt.J", STANDARD, INFO) {
   17.24 +    J("-J", "opt.arg.flag", "opt.J", STANDARD, INFO, true) {
   17.25          @Override
   17.26          public boolean process(OptionHelper helper, String option) {
   17.27              throw new AssertionError
   17.28 @@ -414,7 +416,7 @@
   17.29  
   17.30      // This option exists only for the purpose of documenting itself.
   17.31      // It's actually implemented by the CommandLine class.
   17.32 -    AT("@", "opt.arg.file", "opt.AT", STANDARD, INFO) {
   17.33 +    AT("@", "opt.arg.file", "opt.AT", STANDARD, INFO, true) {
   17.34          @Override
   17.35          public boolean process(OptionHelper helper, String option) {
   17.36              throw new AssertionError("the @ flag should be caught by CommandLine.");

    18.1 --- a/src/share/classes/com/sun/tools/javac/resources/javac.properties	Thu Jan 10 09:56:09 2013 -0800
    18.2 +++ b/src/share/classes/com/sun/tools/javac/resources/javac.properties	Thu Jan 10 15:53:02 2013 -0800
    18.3 @@ -55,6 +55,8 @@
    18.4      Specify where to find annotation processors
    18.5  javac.opt.processor=\
    18.6      Names of the annotation processors to run; bypasses default discovery process
    18.7 +javac.opt.parameters=\
    18.8 +    Generate metadata for reflection on method parameters
    18.9  javac.opt.proc.none.only=\
   18.10      Control whether annotation processing and/or compilation is done.
   18.11  javac.opt.d=\

    19.1 --- a/src/share/classes/com/sun/tools/javac/tree/Pretty.java	Thu Jan 10 09:56:09 2013 -0800
    19.2 +++ b/src/share/classes/com/sun/tools/javac/tree/Pretty.java	Thu Jan 10 15:53:02 2013 -0800
    19.3 @@ -1,5 +1,5 @@
    19.4  /*
    19.5 - * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
    19.6 + * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    19.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    19.8   *
    19.9   * This code is free software; you can redistribute it and/or modify it
   19.10 @@ -154,12 +154,13 @@
   19.11          }
   19.12          //we need to (i) replace all line terminators with a space and (ii) remove
   19.13          //occurrences of 'missing' in the Pretty output (generated when types are missing)
   19.14 -        String res = s.toString().replaceAll("\\s+", " ").replaceAll("/\\*missing\\*/", "");
   19.15 +        String res = s.toString().trim().replaceAll("\\s+", " ").replaceAll("/\\*missing\\*/", "");
   19.16          if (res.length() < maxLength) {
   19.17              return res;
   19.18          } else {
   19.19 -            int split = (maxLength - trimSequence.length()) * 2 / 3;
   19.20 -            return res.substring(0, split) + trimSequence + res.substring(split);
   19.21 +            int head = (maxLength - trimSequence.length()) * 2 / 3;
   19.22 +            int tail = maxLength - trimSequence.length() - head;
   19.23 +            return res.substring(0, head) + trimSequence + res.substring(res.length() - tail);
   19.24          }
   19.25      }
   19.26  

    20.1 --- a/src/share/classes/com/sun/tools/javac/util/Names.java	Thu Jan 10 09:56:09 2013 -0800
    20.2 +++ b/src/share/classes/com/sun/tools/javac/util/Names.java	Thu Jan 10 15:53:02 2013 -0800
    20.3 @@ -132,6 +132,7 @@
    20.4      public final Name LineNumberTable;
    20.5      public final Name LocalVariableTable;
    20.6      public final Name LocalVariableTypeTable;
    20.7 +    public final Name MethodParameters;
    20.8      public final Name RuntimeInvisibleAnnotations;
    20.9      public final Name RuntimeInvisibleParameterAnnotations;
   20.10      public final Name RuntimeInvisibleTypeAnnotations;
   20.11 @@ -265,6 +266,7 @@
   20.12          LineNumberTable = fromString("LineNumberTable");
   20.13          LocalVariableTable = fromString("LocalVariableTable");
   20.14          LocalVariableTypeTable = fromString("LocalVariableTypeTable");
   20.15 +        MethodParameters = fromString("MethodParameters");
   20.16          RuntimeInvisibleAnnotations = fromString("RuntimeInvisibleAnnotations");
   20.17          RuntimeInvisibleParameterAnnotations = fromString("RuntimeInvisibleParameterAnnotations");
   20.18          RuntimeInvisibleTypeAnnotations = fromString("RuntimeInvisibleTypeAnnotations");

    21.1 --- a/src/share/classes/com/sun/tools/javadoc/AnnotationDescImpl.java	Thu Jan 10 09:56:09 2013 -0800
    21.2 +++ b/src/share/classes/com/sun/tools/javadoc/AnnotationDescImpl.java	Thu Jan 10 15:53:02 2013 -0800
    21.3 @@ -89,6 +89,15 @@
    21.4      }
    21.5  
    21.6      /**
    21.7 +     * Check for the synthesized bit on the annotation.
    21.8 +     *
    21.9 +     * @return true if the annotation is synthesized.
   21.10 +     */
   21.11 +    public boolean isSynthesized() {
   21.12 +        return annotation.isSynthesized();
   21.13 +    }
   21.14 +
   21.15 +    /**
   21.16       * Returns a string representation of this annotation.
   21.17       * String is of one of the forms:
   21.18       *     @com.example.foo(name1=val1, name2=val2)

    22.1 --- a/src/share/classes/com/sun/tools/javadoc/Messager.java	Thu Jan 10 09:56:09 2013 -0800
    22.2 +++ b/src/share/classes/com/sun/tools/javadoc/Messager.java	Thu Jan 10 15:53:02 2013 -0800
    22.3 @@ -1,5 +1,5 @@
    22.4  /*
    22.5 - * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
    22.6 + * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
    22.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    22.8   *
    22.9   * This code is free software; you can redistribute it and/or modify it
   22.10 @@ -133,16 +133,6 @@
   22.11          this.programName = programName;
   22.12      }
   22.13  
   22.14 -    @Override
   22.15 -    protected int getDefaultMaxErrors() {
   22.16 -        return Integer.MAX_VALUE;
   22.17 -    }
   22.18 -
   22.19 -    @Override
   22.20 -    protected int getDefaultMaxWarnings() {
   22.21 -        return Integer.MAX_VALUE;
   22.22 -    }
   22.23 -
   22.24      public void setLocale(Locale locale) {
   22.25          this.locale = locale;
   22.26      }

    23.1 --- a/src/share/classes/com/sun/tools/javadoc/MethodDocImpl.java	Thu Jan 10 09:56:09 2013 -0800
    23.2 +++ b/src/share/classes/com/sun/tools/javadoc/MethodDocImpl.java	Thu Jan 10 15:53:02 2013 -0800
    23.3 @@ -86,16 +86,7 @@
    23.4       * Return true if this method is abstract
    23.5       */
    23.6      public boolean isAbstract() {
    23.7 -        //### This is dubious, but old 'javadoc' apparently does it.
    23.8 -        //### I regard this as a bug and an obstacle to treating the
    23.9 -        //### doclet API as a proper compile-time reflection facility.
   23.10 -        //### (maddox 09/26/2000)
   23.11 -        if (containingClass().isInterface()) {
   23.12 -            //### Don't force creation of ClassDocImpl for super here.
   23.13 -            // Abstract modifier is implicit.  Strip/canonicalize it.
   23.14 -            return false;
   23.15 -        }
   23.16 -        return Modifier.isAbstract(getModifiers());
   23.17 +        return (Modifier.isAbstract(getModifiers()) && !isDefault());
   23.18      }
   23.19  
   23.20      /**

    24.1 --- a/src/share/classes/com/sun/tools/javap/AttributeWriter.java	Thu Jan 10 09:56:09 2013 -0800
    24.2 +++ b/src/share/classes/com/sun/tools/javap/AttributeWriter.java	Thu Jan 10 15:53:02 2013 -0800
    24.3 @@ -1,5 +1,5 @@
    24.4  /*
    24.5 - * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
    24.6 + * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
    24.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    24.8   *
    24.9   * This code is free software; you can redistribute it and/or modify it
   24.10 @@ -46,6 +46,7 @@
   24.11  import com.sun.tools.classfile.LineNumberTable_attribute;
   24.12  import com.sun.tools.classfile.LocalVariableTable_attribute;
   24.13  import com.sun.tools.classfile.LocalVariableTypeTable_attribute;
   24.14 +import com.sun.tools.classfile.MethodParameters_attribute;
   24.15  import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;
   24.16  import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;
   24.17  import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;
   24.18 @@ -386,6 +387,28 @@
   24.19          return null;
   24.20      }
   24.21  
   24.22 +    private static final String format = "%-31s%s";
   24.23 +
   24.24 +    public Void visitMethodParameters(MethodParameters_attribute attr,
   24.25 +                                      Void ignore) {
   24.26 +
   24.27 +        final String header = String.format(format, "Name", "Flags");
   24.28 +        println("MethodParameters:");
   24.29 +        indent(+1);
   24.30 +        println(header);
   24.31 +        for (MethodParameters_attribute.Entry entry :
   24.32 +                 attr.method_parameter_table) {
   24.33 +            String flagstr =
   24.34 +                (0 != (entry.flags & ACC_FINAL) ? " final" : "") +
   24.35 +                (0 != (entry.flags & ACC_SYNTHETIC) ? " synthetic" : "");
   24.36 +            println(String.format(format,
   24.37 +                                  constantWriter.stringValue(entry.name_index),
   24.38 +                                  flagstr));
   24.39 +        }
   24.40 +        indent(-1);
   24.41 +        return null;
   24.42 +    }
   24.43 +
   24.44      public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, Void ignore) {
   24.45          println("RuntimeVisibleAnnotations:");
   24.46          indent(+1);

    25.1 --- a/src/share/classes/com/sun/tools/javap/ClassWriter.java	Thu Jan 10 09:56:09 2013 -0800
    25.2 +++ b/src/share/classes/com/sun/tools/javap/ClassWriter.java	Thu Jan 10 15:53:02 2013 -0800
    25.3 @@ -1,5 +1,5 @@
    25.4  /*
    25.5 - * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
    25.6 + * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
    25.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    25.8   *
    25.9   * This code is free software; you can redistribute it and/or modify it
   25.10 @@ -206,7 +206,7 @@
   25.11              println("minor version: " + cf.minor_version);
   25.12              println("major version: " + cf.major_version);
   25.13              if (!options.compat)
   25.14 -              writeList("flags: ", flags.getClassFlags(), NEWLINE);
   25.15 +              writeList("flags: ", flags.getClassFlags(), "\n");
   25.16              indent(-1);
   25.17              constantWriter.writeConstantPool();
   25.18          } else {
   25.19 @@ -383,7 +383,7 @@
   25.20              println("Signature: " + getValue(f.descriptor));
   25.21  
   25.22          if (options.verbose && !options.compat)
   25.23 -            writeList("flags: ", flags.getFieldFlags(), NEWLINE);
   25.24 +            writeList("flags: ", flags.getFieldFlags(), "\n");
   25.25  
   25.26          if (options.showAllAttrs) {
   25.27              for (Attribute attr: f.attributes)
   25.28 @@ -480,7 +480,7 @@
   25.29          }
   25.30  
   25.31          if (options.verbose && !options.compat) {
   25.32 -            writeList("flags: ", flags.getMethodFlags(), NEWLINE);
   25.33 +            writeList("flags: ", flags.getMethodFlags(), "\n");
   25.34          }
   25.35  
   25.36          Code_attribute code = null;
   25.37 @@ -749,5 +749,4 @@
   25.38      private int size;
   25.39      private ConstantPool constant_pool;
   25.40      private Method method;
   25.41 -    private static final String NEWLINE = System.getProperty("line.separator", "\n");
   25.42  }

    26.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    26.2 +++ b/src/share/classes/com/sun/tools/jdeps/Archive.java	Thu Jan 10 15:53:02 2013 -0800
    26.3 @@ -0,0 +1,173 @@
    26.4 +/*
    26.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    26.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    26.7 + *
    26.8 + * This code is free software; you can redistribute it and/or modify it
    26.9 + * under the terms of the GNU General Public License version 2 only, as
   26.10 + * published by the Free Software Foundation.  Oracle designates this
   26.11 + * particular file as subject to the "Classpath" exception as provided
   26.12 + * by Oracle in the LICENSE file that accompanied this code.
   26.13 + *
   26.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   26.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   26.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   26.17 + * version 2 for more details (a copy is included in the LICENSE file that
   26.18 + * accompanied this code).
   26.19 + *
   26.20 + * You should have received a copy of the GNU General Public License version
   26.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   26.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   26.23 + *
   26.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   26.25 + * or visit www.oracle.com if you need additional information or have any
   26.26 + * questions.
   26.27 + */
   26.28 +package com.sun.tools.jdeps;
   26.29 +
   26.30 +import com.sun.tools.classfile.Dependency;
   26.31 +import com.sun.tools.classfile.Dependency.Location;
   26.32 +import java.io.File;
   26.33 +import java.util.Comparator;
   26.34 +import java.util.HashMap;
   26.35 +import java.util.HashSet;
   26.36 +import java.util.Map;
   26.37 +import java.util.Set;
   26.38 +import java.util.SortedMap;
   26.39 +import java.util.SortedSet;
   26.40 +import java.util.TreeMap;
   26.41 +import java.util.TreeSet;
   26.42 +
   26.43 +/**
   26.44 + * Represents the source of the class files.
   26.45 + */
   26.46 +public class Archive {
   26.47 +    private static Map<String,Archive> archiveForClass = new HashMap<String,Archive>();
   26.48 +    public static Archive find(Location loc) {
   26.49 +        return archiveForClass.get(loc.getName());
   26.50 +    }
   26.51 +
   26.52 +    private final File file;
   26.53 +    private final String filename;
   26.54 +    private final DependencyRecorder recorder;
   26.55 +    private final ClassFileReader reader;
   26.56 +    public Archive(String name) {
   26.57 +        this.file = null;
   26.58 +        this.filename = name;
   26.59 +        this.recorder = new DependencyRecorder();
   26.60 +        this.reader = null;
   26.61 +    }
   26.62 +
   26.63 +    public Archive(File f, ClassFileReader reader) {
   26.64 +        this.file = f;
   26.65 +        this.filename = f.getName();
   26.66 +        this.recorder = new DependencyRecorder();
   26.67 +        this.reader = reader;
   26.68 +    }
   26.69 +
   26.70 +    public ClassFileReader reader() {
   26.71 +        return reader;
   26.72 +    }
   26.73 +
   26.74 +    public String getFileName() {
   26.75 +        return filename;
   26.76 +    }
   26.77 +
   26.78 +    public void addClass(String classFileName) {
   26.79 +        Archive a = archiveForClass.get(classFileName);
   26.80 +        assert(a == null || a == this); // ## issue warning?
   26.81 +        if (!archiveForClass.containsKey(classFileName)) {
   26.82 +            archiveForClass.put(classFileName, this);
   26.83 +        }
   26.84 +    }
   26.85 +
   26.86 +    public void addDependency(Dependency d) {
   26.87 +        recorder.addDependency(d);
   26.88 +    }
   26.89 +
   26.90 +    /**
   26.91 +     * Returns a sorted map of a class to its dependencies.
   26.92 +     */
   26.93 +    public SortedMap<Location, SortedSet<Location>> getDependencies() {
   26.94 +        DependencyRecorder.Filter filter = new DependencyRecorder.Filter() {
   26.95 +            public boolean accept(Location origin, Location target) {
   26.96 +                 return (archiveForClass.get(origin.getName()) !=
   26.97 +                            archiveForClass.get(target.getName()));
   26.98 +        }};
   26.99 +
  26.100 +        SortedMap<Location, SortedSet<Location>> result =
  26.101 +            new TreeMap<Location, SortedSet<Location>>(locationComparator);
  26.102 +        for (Map.Entry<Location, Set<Location>> e : recorder.dependencies().entrySet()) {
  26.103 +            Location o = e.getKey();
  26.104 +            for (Location t : e.getValue()) {
  26.105 +                if (filter.accept(o, t)) {
  26.106 +                    SortedSet<Location> odeps = result.get(o);
  26.107 +                    if (odeps == null) {
  26.108 +                        odeps = new TreeSet<Location>(locationComparator);
  26.109 +                        result.put(o, odeps);
  26.110 +                    }
  26.111 +                    odeps.add(t);
  26.112 +                }
  26.113 +            }
  26.114 +        }
  26.115 +        return result;
  26.116 +    }
  26.117 +
  26.118 +    /**
  26.119 +     * Returns the set of archives this archive requires.
  26.120 +     */
  26.121 +    public Set<Archive> getRequiredArchives() {
  26.122 +        SortedSet<Archive> deps = new TreeSet<Archive>(new Comparator<Archive>() {
  26.123 +            public int compare(Archive a1, Archive a2) {
  26.124 +                return a1.toString().compareTo(a2.toString());
  26.125 +            }
  26.126 +        });
  26.127 +
  26.128 +        for (Map.Entry<Location, Set<Location>> e : recorder.dependencies().entrySet()) {
  26.129 +            Location o = e.getKey();
  26.130 +            Archive origin = Archive.find(o);
  26.131 +            for (Location t : e.getValue()) {
  26.132 +                Archive target = Archive.find(t);
  26.133 +                assert(origin != null && target != null);
  26.134 +                if (origin != target) {
  26.135 +                    if (!deps.contains(target)) {
  26.136 +                        deps.add(target);
  26.137 +                    }
  26.138 +                }
  26.139 +            }
  26.140 +        }
  26.141 +        return deps;
  26.142 +    }
  26.143 +
  26.144 +    public String toString() {
  26.145 +        return file != null ? file.getPath() : filename;
  26.146 +    }
  26.147 +
  26.148 +    private static class DependencyRecorder {
  26.149 +        static interface Filter {
  26.150 +            boolean accept(Location origin, Location target);
  26.151 +        }
  26.152 +
  26.153 +        public void addDependency(Dependency d) {
  26.154 +            Set<Location> odeps = map.get(d.getOrigin());
  26.155 +            if (odeps == null) {
  26.156 +                odeps = new HashSet<Location>();
  26.157 +                map.put(d.getOrigin(), odeps);
  26.158 +            }
  26.159 +            odeps.add(d.getTarget());
  26.160 +        }
  26.161 +
  26.162 +        public Map<Location, Set<Location>> dependencies() {
  26.163 +            return map;
  26.164 +        }
  26.165 +
  26.166 +        private final Map<Location, Set<Location>> map =
  26.167 +            new HashMap<Location, Set<Location>>();
  26.168 +    }
  26.169 +
  26.170 +    private static Comparator<Location> locationComparator =
  26.171 +        new Comparator<Location>() {
  26.172 +            public int compare(Location o1, Location o2) {
  26.173 +                return o1.toString().compareTo(o2.toString());
  26.174 +            }
  26.175 +        };
  26.176 +}

    27.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    27.2 +++ b/src/share/classes/com/sun/tools/jdeps/ClassFileReader.java	Thu Jan 10 15:53:02 2013 -0800
    27.3 @@ -0,0 +1,326 @@
    27.4 +/*
    27.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    27.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    27.7 + *
    27.8 + * This code is free software; you can redistribute it and/or modify it
    27.9 + * under the terms of the GNU General Public License version 2 only, as
   27.10 + * published by the Free Software Foundation.  Oracle designates this
   27.11 + * particular file as subject to the "Classpath" exception as provided
   27.12 + * by Oracle in the LICENSE file that accompanied this code.
   27.13 + *
   27.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   27.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   27.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   27.17 + * version 2 for more details (a copy is included in the LICENSE file that
   27.18 + * accompanied this code).
   27.19 + *
   27.20 + * You should have received a copy of the GNU General Public License version
   27.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   27.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   27.23 + *
   27.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   27.25 + * or visit www.oracle.com if you need additional information or have any
   27.26 + * questions.
   27.27 + */
   27.28 +package com.sun.tools.jdeps;
   27.29 +
   27.30 +import com.sun.tools.classfile.ClassFile;
   27.31 +import com.sun.tools.classfile.ConstantPoolException;
   27.32 +import com.sun.tools.classfile.Dependencies.ClassFileError;
   27.33 +import java.io.*;
   27.34 +import java.nio.file.FileVisitResult;
   27.35 +import java.nio.file.Files;
   27.36 +import java.nio.file.Path;
   27.37 +import java.nio.file.SimpleFileVisitor;
   27.38 +import java.nio.file.attribute.BasicFileAttributes;
   27.39 +import java.util.*;
   27.40 +import java.util.jar.JarEntry;
   27.41 +import java.util.jar.JarFile;
   27.42 +
   27.43 +/**
   27.44 + * ClassFileReader reads ClassFile(s) of a given path that can be
   27.45 + * a .class file, a directory, or a JAR file.
   27.46 + */
   27.47 +public class ClassFileReader {
   27.48 +    /**
   27.49 +     * Returns a ClassFileReader instance of a given path.
   27.50 +     */
   27.51 +    public static ClassFileReader newInstance(File path) throws IOException {
   27.52 +        if (!path.exists()) {
   27.53 +            throw new FileNotFoundException(path.getAbsolutePath());
   27.54 +        }
   27.55 +
   27.56 +        if (path.isDirectory()) {
   27.57 +            return new DirectoryReader(path.toPath());
   27.58 +        } else if (path.getName().endsWith(".jar")) {
   27.59 +            return new JarFileReader(path.toPath());
   27.60 +        } else {
   27.61 +            return new ClassFileReader(path.toPath());
   27.62 +        }
   27.63 +    }
   27.64 +
   27.65 +    protected final Path path;
   27.66 +    protected final String baseFileName;
   27.67 +    private ClassFileReader(Path path) {
   27.68 +        this.path = path;
   27.69 +        this.baseFileName = path.getFileName() != null
   27.70 +                                ? path.getFileName().toString()
   27.71 +                                : path.toString();
   27.72 +    }
   27.73 +
   27.74 +    public String getFileName() {
   27.75 +        return baseFileName;
   27.76 +    }
   27.77 +
   27.78 +    /**
   27.79 +     * Returns the ClassFile matching the given binary name
   27.80 +     * or a fully-qualified class name.
   27.81 +     */
   27.82 +    public ClassFile getClassFile(String name) throws IOException {
   27.83 +        if (name.indexOf('.') > 0) {
   27.84 +            int i = name.lastIndexOf('.');
   27.85 +            String pathname = name.replace('.', File.separatorChar) + ".class";
   27.86 +            if (baseFileName.equals(pathname) ||
   27.87 +                    baseFileName.equals(pathname.substring(0, i) + "$" +
   27.88 +                                        pathname.substring(i+1, pathname.length()))) {
   27.89 +                return readClassFile(path);
   27.90 +            }
   27.91 +        } else {
   27.92 +            if (baseFileName.equals(name.replace('/', File.separatorChar) + ".class")) {
   27.93 +                return readClassFile(path);
   27.94 +            }
   27.95 +        }
   27.96 +        return null;
   27.97 +    }
   27.98 +
   27.99 +    public Iterable<ClassFile> getClassFiles() throws IOException {
  27.100 +        return new Iterable<ClassFile>() {
  27.101 +            public Iterator<ClassFile> iterator() {
  27.102 +                return new FileIterator();
  27.103 +            }
  27.104 +        };
  27.105 +    }
  27.106 +
  27.107 +    protected ClassFile readClassFile(Path p) throws IOException {
  27.108 +        InputStream is = null;
  27.109 +        try {
  27.110 +            is = Files.newInputStream(p);
  27.111 +            return ClassFile.read(is);
  27.112 +        } catch (ConstantPoolException e) {
  27.113 +            throw new ClassFileError(e);
  27.114 +        } finally {
  27.115 +            if (is != null) {
  27.116 +                is.close();
  27.117 +            }
  27.118 +        }
  27.119 +    }
  27.120 +
  27.121 +    class FileIterator implements Iterator<ClassFile> {
  27.122 +        int count;
  27.123 +        FileIterator() {
  27.124 +            this.count = 0;
  27.125 +        }
  27.126 +        public boolean hasNext() {
  27.127 +            return count == 0 && baseFileName.endsWith(".class");
  27.128 +        }
  27.129 +
  27.130 +        public ClassFile next() {
  27.131 +            if (!hasNext()) {
  27.132 +                throw new NoSuchElementException();
  27.133 +            }
  27.134 +            try {
  27.135 +                ClassFile cf = readClassFile(path);
  27.136 +                count++;
  27.137 +                return cf;
  27.138 +            } catch (IOException e) {
  27.139 +                throw new ClassFileError(e);
  27.140 +            }
  27.141 +        }
  27.142 +
  27.143 +        public void remove() {
  27.144 +            throw new UnsupportedOperationException("Not supported yet.");
  27.145 +        }
  27.146 +    }
  27.147 +
  27.148 +    public String toString() {
  27.149 +        return path.toString();
  27.150 +    }
  27.151 +
  27.152 +    private static class DirectoryReader extends ClassFileReader {
  27.153 +        DirectoryReader(Path path) throws IOException {
  27.154 +            super(path);
  27.155 +        }
  27.156 +
  27.157 +        public ClassFile getClassFile(String name) throws IOException {
  27.158 +            if (name.indexOf('.') > 0) {
  27.159 +                int i = name.lastIndexOf('.');
  27.160 +                String pathname = name.replace('.', File.separatorChar) + ".class";
  27.161 +                Path p = path.resolve(pathname);
  27.162 +                if (!p.toFile().exists()) {
  27.163 +                    p = path.resolve(pathname.substring(0, i) + "$" +
  27.164 +                                     pathname.substring(i+1, pathname.length()));
  27.165 +                }
  27.166 +                if (p.toFile().exists()) {
  27.167 +                    return readClassFile(p);
  27.168 +                }
  27.169 +            } else {
  27.170 +                Path p = path.resolve(name + ".class");
  27.171 +                if (p.toFile().exists()) {
  27.172 +                    return readClassFile(p);
  27.173 +                }
  27.174 +            }
  27.175 +            return null;
  27.176 +        }
  27.177 +
  27.178 +        public Iterable<ClassFile> getClassFiles() throws IOException {
  27.179 +            final Iterator<ClassFile> iter = new DirectoryIterator();
  27.180 +            return new Iterable<ClassFile>() {
  27.181 +                public Iterator<ClassFile> iterator() {
  27.182 +                    return iter;
  27.183 +                }
  27.184 +            };
  27.185 +        }
  27.186 +
  27.187 +        private List<Path> walkTree(Path dir) throws IOException {
  27.188 +            final List<Path> files = new ArrayList<Path>();
  27.189 +            Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
  27.190 +                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
  27.191 +                        throws IOException {
  27.192 +                    if (file.toFile().getName().endsWith(".class")) {
  27.193 +                        files.add(file);
  27.194 +                    }
  27.195 +                    return FileVisitResult.CONTINUE;
  27.196 +                }
  27.197 +            });
  27.198 +            return files;
  27.199 +        }
  27.200 +
  27.201 +        class DirectoryIterator implements Iterator<ClassFile> {
  27.202 +            private List<Path> entries;
  27.203 +            private int index = 0;
  27.204 +            DirectoryIterator() throws IOException {
  27.205 +                entries = walkTree(path);
  27.206 +                index = 0;
  27.207 +            }
  27.208 +
  27.209 +            public boolean hasNext() {
  27.210 +                return index != entries.size();
  27.211 +            }
  27.212 +
  27.213 +            public ClassFile next() {
  27.214 +                if (!hasNext()) {
  27.215 +                    throw new NoSuchElementException();
  27.216 +                }
  27.217 +                Path path = entries.get(index++);
  27.218 +                try {
  27.219 +                    return readClassFile(path);
  27.220 +                } catch (IOException e) {
  27.221 +                    throw new ClassFileError(e);
  27.222 +                }
  27.223 +            }
  27.224 +
  27.225 +            public void remove() {
  27.226 +                throw new UnsupportedOperationException("Not supported yet.");
  27.227 +            }
  27.228 +        }
  27.229 +    }
  27.230 +
  27.231 +    private static class JarFileReader extends ClassFileReader {
  27.232 +        final JarFile jarfile;
  27.233 +        JarFileReader(Path path) throws IOException {
  27.234 +            super(path);
  27.235 +            this.jarfile = new JarFile(path.toFile());
  27.236 +        }
  27.237 +
  27.238 +        public ClassFile getClassFile(String name) throws IOException {
  27.239 +            if (name.indexOf('.') > 0) {
  27.240 +                int i = name.lastIndexOf('.');
  27.241 +                String entryName = name.replace('.', '/') + ".class";
  27.242 +                JarEntry e = jarfile.getJarEntry(entryName);
  27.243 +                if (e == null) {
  27.244 +                    e = jarfile.getJarEntry(entryName.substring(0, i) + "$"
  27.245 +                            + entryName.substring(i + 1, entryName.length()));
  27.246 +                }
  27.247 +                if (e != null) {
  27.248 +                    return readClassFile(e);
  27.249 +                }
  27.250 +            } else {
  27.251 +                JarEntry e = jarfile.getJarEntry(name + ".class");
  27.252 +                if (e != null) {
  27.253 +                    return readClassFile(e);
  27.254 +                }
  27.255 +            }
  27.256 +            return null;
  27.257 +        }
  27.258 +
  27.259 +        private ClassFile readClassFile(JarEntry e) throws IOException {
  27.260 +            InputStream is = null;
  27.261 +            try {
  27.262 +                is = jarfile.getInputStream(e);
  27.263 +                return ClassFile.read(is);
  27.264 +            } catch (ConstantPoolException ex) {
  27.265 +                throw new ClassFileError(ex);
  27.266 +            } finally {
  27.267 +                if (is != null)
  27.268 +                    is.close();
  27.269 +            }
  27.270 +        }
  27.271 +
  27.272 +        public Iterable<ClassFile> getClassFiles() throws IOException {
  27.273 +            final Iterator<ClassFile> iter = new JarFileIterator();
  27.274 +            return new Iterable<ClassFile>() {
  27.275 +                public Iterator<ClassFile> iterator() {
  27.276 +                    return iter;
  27.277 +                }
  27.278 +            };
  27.279 +        }
  27.280 +
  27.281 +        class JarFileIterator implements Iterator<ClassFile> {
  27.282 +            private Enumeration<JarEntry> entries;
  27.283 +            private JarEntry nextEntry;
  27.284 +            JarFileIterator() {
  27.285 +                this.entries = jarfile.entries();
  27.286 +                while (entries.hasMoreElements()) {
  27.287 +                    JarEntry e = entries.nextElement();
  27.288 +                    String name = e.getName();
  27.289 +                    if (name.endsWith(".class")) {
  27.290 +                        this.nextEntry = e;
  27.291 +                        break;
  27.292 +                    }
  27.293 +                }
  27.294 +            }
  27.295 +
  27.296 +            public boolean hasNext() {
  27.297 +                return nextEntry != null;
  27.298 +            }
  27.299 +
  27.300 +            public ClassFile next() {
  27.301 +                if (!hasNext()) {
  27.302 +                    throw new NoSuchElementException();
  27.303 +                }
  27.304 +
  27.305 +                ClassFile cf;
  27.306 +                try {
  27.307 +                    cf = readClassFile(nextEntry);
  27.308 +                } catch (IOException ex) {
  27.309 +                    throw new ClassFileError(ex);
  27.310 +                }
  27.311 +                JarEntry entry = nextEntry;
  27.312 +                nextEntry = null;
  27.313 +                while (entries.hasMoreElements()) {
  27.314 +                    JarEntry e = entries.nextElement();
  27.315 +                    String name = e.getName();
  27.316 +                    if (name.endsWith(".class")) {
  27.317 +                        nextEntry = e;
  27.318 +                        break;
  27.319 +                    }
  27.320 +                }
  27.321 +                return cf;
  27.322 +            }
  27.323 +
  27.324 +            public void remove() {
  27.325 +                throw new UnsupportedOperationException("Not supported yet.");
  27.326 +            }
  27.327 +        }
  27.328 +    }
  27.329 +}

    28.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    28.2 +++ b/src/share/classes/com/sun/tools/jdeps/JdepsTask.java	Thu Jan 10 15:53:02 2013 -0800
    28.3 @@ -0,0 +1,650 @@
    28.4 +/*
    28.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    28.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    28.7 + *
    28.8 + * This code is free software; you can redistribute it and/or modify it
    28.9 + * under the terms of the GNU General Public License version 2 only, as
   28.10 + * published by the Free Software Foundation.  Oracle designates this
   28.11 + * particular file as subject to the "Classpath" exception as provided
   28.12 + * by Oracle in the LICENSE file that accompanied this code.
   28.13 + *
   28.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   28.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   28.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   28.17 + * version 2 for more details (a copy is included in the LICENSE file that
   28.18 + * accompanied this code).
   28.19 + *
   28.20 + * You should have received a copy of the GNU General Public License version
   28.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   28.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   28.23 + *
   28.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   28.25 + * or visit www.oracle.com if you need additional information or have any
   28.26 + * questions.
   28.27 + */
   28.28 +package com.sun.tools.jdeps;
   28.29 +
   28.30 +import com.sun.tools.classfile.ClassFile;
   28.31 +import com.sun.tools.classfile.ConstantPoolException;
   28.32 +import com.sun.tools.classfile.Dependencies;
   28.33 +import com.sun.tools.classfile.Dependencies.ClassFileError;
   28.34 +import com.sun.tools.classfile.Dependency;
   28.35 +import com.sun.tools.classfile.Dependency.Location;
   28.36 +import java.io.*;
   28.37 +import java.text.MessageFormat;
   28.38 +import java.util.*;
   28.39 +import java.util.regex.Pattern;
   28.40 +
   28.41 +/**
   28.42 + * Implementation for the jdeps tool for static class dependency analysis.
   28.43 + */
   28.44 +class JdepsTask {
   28.45 +    class BadArgs extends Exception {
   28.46 +        static final long serialVersionUID = 8765093759964640721L;
   28.47 +        BadArgs(String key, Object... args) {
   28.48 +            super(JdepsTask.this.getMessage(key, args));
   28.49 +            this.key = key;
   28.50 +            this.args = args;
   28.51 +        }
   28.52 +
   28.53 +        BadArgs showUsage(boolean b) {
   28.54 +            showUsage = b;
   28.55 +            return this;
   28.56 +        }
   28.57 +        final String key;
   28.58 +        final Object[] args;
   28.59 +        boolean showUsage;
   28.60 +    }
   28.61 +
   28.62 +    static abstract class Option {
   28.63 +        Option(boolean hasArg, String... aliases) {
   28.64 +            this.hasArg = hasArg;
   28.65 +            this.aliases = aliases;
   28.66 +        }
   28.67 +
   28.68 +        boolean isHidden() {
   28.69 +            return false;
   28.70 +        }
   28.71 +
   28.72 +        boolean matches(String opt) {
   28.73 +            for (String a : aliases) {
   28.74 +                if (a.equals(opt)) {
   28.75 +                    return true;
   28.76 +                } else if (opt.startsWith("--") && hasArg && opt.startsWith(a + "=")) {
   28.77 +                    return true;
   28.78 +                }
   28.79 +            }
   28.80 +            return false;
   28.81 +        }
   28.82 +
   28.83 +        boolean ignoreRest() {
   28.84 +            return false;
   28.85 +        }
   28.86 +
   28.87 +        abstract void process(JdepsTask task, String opt, String arg) throws BadArgs;
   28.88 +        final boolean hasArg;
   28.89 +        final String[] aliases;
   28.90 +    }
   28.91 +
   28.92 +    static abstract class HiddenOption extends Option {
   28.93 +        HiddenOption(boolean hasArg, String... aliases) {
   28.94 +            super(hasArg, aliases);
   28.95 +        }
   28.96 +
   28.97 +        boolean isHidden() {
   28.98 +            return true;
   28.99 +        }
  28.100 +    }
  28.101 +
  28.102 +    static Option[] recognizedOptions = {
  28.103 +        new Option(false, "-h", "-?", "--help") {
  28.104 +            void process(JdepsTask task, String opt, String arg) {
  28.105 +                task.options.help = true;
  28.106 +            }
  28.107 +        },
  28.108 +        new Option(false, "-s", "--summary") {
  28.109 +            void process(JdepsTask task, String opt, String arg) {
  28.110 +                task.options.showSummary = true;
  28.111 +                task.options.verbose = Options.Verbose.SUMMARY;
  28.112 +            }
  28.113 +        },
  28.114 +        new Option(false, "-v", "--verbose") {
  28.115 +            void process(JdepsTask task, String opt, String arg) {
  28.116 +                task.options.verbose = Options.Verbose.VERBOSE;
  28.117 +            }
  28.118 +        },
  28.119 +        new Option(true, "-V", "--verbose-level") {
  28.120 +            void process(JdepsTask task, String opt, String arg) throws BadArgs {
  28.121 +                switch (arg) {
  28.122 +                    case "package":
  28.123 +                        task.options.verbose = Options.Verbose.PACKAGE;
  28.124 +                        break;
  28.125 +                    case "class":
  28.126 +                        task.options.verbose = Options.Verbose.CLASS;
  28.127 +                        break;
  28.128 +                    default:
  28.129 +                        throw task.new BadArgs("err.invalid.arg.for.option", opt);
  28.130 +                }
  28.131 +            }
  28.132 +        },
  28.133 +        new Option(true, "-c", "--classpath") {
  28.134 +            void process(JdepsTask task, String opt, String arg) {
  28.135 +                task.options.classpath = arg;
  28.136 +            }
  28.137 +        },
  28.138 +        new Option(true, "-p", "--package") {
  28.139 +            void process(JdepsTask task, String opt, String arg) {
  28.140 +                task.options.packageNames.add(arg);
  28.141 +            }
  28.142 +        },
  28.143 +        new Option(true, "-e", "--regex") {
  28.144 +            void process(JdepsTask task, String opt, String arg) {
  28.145 +                task.options.regex = arg;
  28.146 +            }
  28.147 +        },
  28.148 +        new Option(false, "-P", "--profile") {
  28.149 +            void process(JdepsTask task, String opt, String arg) {
  28.150 +                task.options.showProfile = true;
  28.151 +            }
  28.152 +        },
  28.153 +        new Option(false, "-R", "--recursive") {
  28.154 +            void process(JdepsTask task, String opt, String arg) {
  28.155 +                task.options.depth = 0;
  28.156 +            }
  28.157 +        },
  28.158 +        new HiddenOption(true, "-d", "--depth") {
  28.159 +            void process(JdepsTask task, String opt, String arg) throws BadArgs {
  28.160 +                try {
  28.161 +                    task.options.depth = Integer.parseInt(arg);
  28.162 +                } catch (NumberFormatException e) {
  28.163 +                    throw task.new BadArgs("err.invalid.arg.for.option", opt);
  28.164 +                }
  28.165 +            }
  28.166 +        },
  28.167 +        new Option(false, "--version") {
  28.168 +            void process(JdepsTask task, String opt, String arg) {
  28.169 +                task.options.version = true;
  28.170 +            }
  28.171 +        },
  28.172 +        new HiddenOption(false, "--fullversion") {
  28.173 +            void process(JdepsTask task, String opt, String arg) {
  28.174 +                task.options.fullVersion = true;
  28.175 +            }
  28.176 +        },
  28.177 +
  28.178 +    };
  28.179 +
  28.180 +    private static final String PROGNAME = "jdeps";
  28.181 +    private final Options options = new Options();
  28.182 +    private final List<String> classes = new ArrayList<String>();
  28.183 +
  28.184 +    private PrintWriter log;
  28.185 +    void setLog(PrintWriter out) {
  28.186 +        log = out;
  28.187 +    }
  28.188 +
  28.189 +    /**
  28.190 +     * Result codes.
  28.191 +     */
  28.192 +    static final int EXIT_OK = 0, // Completed with no errors.
  28.193 +                     EXIT_ERROR = 1, // Completed but reported errors.
  28.194 +                     EXIT_CMDERR = 2, // Bad command-line arguments
  28.195 +                     EXIT_SYSERR = 3, // System error or resource exhaustion.
  28.196 +                     EXIT_ABNORMAL = 4;// terminated abnormally
  28.197 +
  28.198 +    int run(String[] args) {
  28.199 +        if (log == null) {
  28.200 +            log = new PrintWriter(System.out);
  28.201 +        }
  28.202 +        try {
  28.203 +            handleOptions(args);
  28.204 +            if (options.help) {
  28.205 +                showHelp();
  28.206 +            }
  28.207 +            if (options.version || options.fullVersion) {
  28.208 +                showVersion(options.fullVersion);
  28.209 +            }
  28.210 +            if (classes.isEmpty() && !options.wildcard) {
  28.211 +                if (options.help || options.version || options.fullVersion) {
  28.212 +                    return EXIT_OK;
  28.213 +                } else {
  28.214 +                    showHelp();
  28.215 +                    return EXIT_CMDERR;
  28.216 +                }
  28.217 +            }
  28.218 +            if (options.regex != null && options.packageNames.size() > 0) {
  28.219 +                showHelp();
  28.220 +                return EXIT_CMDERR;
  28.221 +            }
  28.222 +            if (options.showSummary && options.verbose != Options.Verbose.SUMMARY) {
  28.223 +                showHelp();
  28.224 +                return EXIT_CMDERR;
  28.225 +            }
  28.226 +            boolean ok = run();
  28.227 +            return ok ? EXIT_OK : EXIT_ERROR;
  28.228 +        } catch (BadArgs e) {
  28.229 +            reportError(e.key, e.args);
  28.230 +            if (e.showUsage) {
  28.231 +                log.println(getMessage("main.usage.summary", PROGNAME));
  28.232 +            }
  28.233 +            return EXIT_CMDERR;
  28.234 +        } catch (IOException e) {
  28.235 +            return EXIT_ABNORMAL;
  28.236 +        } finally {
  28.237 +            log.flush();
  28.238 +        }
  28.239 +    }
  28.240 +
  28.241 +    private final List<Archive> sourceLocations = new ArrayList<Archive>();
  28.242 +    private final Archive NOT_FOUND = new Archive(getMessage("artifact.not.found"));
  28.243 +    private boolean run() throws IOException {
  28.244 +        findDependencies();
  28.245 +        switch (options.verbose) {
  28.246 +            case VERBOSE:
  28.247 +            case CLASS:
  28.248 +                printClassDeps(log);
  28.249 +                break;
  28.250 +            case PACKAGE:
  28.251 +                printPackageDeps(log);
  28.252 +                break;
  28.253 +            case SUMMARY:
  28.254 +                for (Archive origin : sourceLocations) {
  28.255 +                    for (Archive target : origin.getRequiredArchives()) {
  28.256 +                        log.format("%-30s -> %s%n", origin, target);
  28.257 +                    }
  28.258 +                }
  28.259 +                break;
  28.260 +            default:
  28.261 +                throw new InternalError("Should not reach here");
  28.262 +        }
  28.263 +        return true;
  28.264 +    }
  28.265 +
  28.266 +    private boolean isValidClassName(String name) {
  28.267 +        if (!Character.isJavaIdentifierStart(name.charAt(0))) {
  28.268 +            return false;
  28.269 +        }
  28.270 +        for (int i=1; i < name.length(); i++) {
  28.271 +            char c = name.charAt(i);
  28.272 +            if (c != '.'  && !Character.isJavaIdentifierPart(c)) {
  28.273 +                return false;
  28.274 +            }
  28.275 +        }
  28.276 +        return true;
  28.277 +    }
  28.278 +
  28.279 +    private void findDependencies() throws IOException {
  28.280 +        Dependency.Finder finder = Dependencies.getClassDependencyFinder();
  28.281 +        Dependency.Filter filter;
  28.282 +        if (options.regex != null) {
  28.283 +            filter = Dependencies.getRegexFilter(Pattern.compile(options.regex));
  28.284 +        } else if (options.packageNames.size() > 0) {
  28.285 +            filter = Dependencies.getPackageFilter(options.packageNames, false);
  28.286 +        } else {
  28.287 +            filter = new Dependency.Filter() {
  28.288 +                public boolean accepts(Dependency dependency) {
  28.289 +                    return !dependency.getOrigin().equals(dependency.getTarget());
  28.290 +                }
  28.291 +            };
  28.292 +        }
  28.293 +
  28.294 +        List<Archive> archives = new ArrayList<Archive>();
  28.295 +        Deque<String> roots = new LinkedList<String>();
  28.296 +        for (String s : classes) {
  28.297 +            File f = new File(s);
  28.298 +            if (f.exists()) {
  28.299 +                archives.add(new Archive(f, ClassFileReader.newInstance(f)));
  28.300 +            } else {
  28.301 +                if (isValidClassName(s)) {
  28.302 +                    roots.add(s);
  28.303 +                } else {
  28.304 +                    warning("warn.invalid.arg", s);
  28.305 +                }
  28.306 +            }
  28.307 +        }
  28.308 +
  28.309 +        List<Archive> classpaths = new ArrayList<Archive>(); // for class file lookup
  28.310 +        if (options.wildcard) {
  28.311 +            // include all archives from classpath to the initial list
  28.312 +            archives.addAll(getClassPathArchives(options.classpath));
  28.313 +        } else {
  28.314 +            classpaths.addAll(getClassPathArchives(options.classpath));
  28.315 +        }
  28.316 +        classpaths.addAll(PlatformClassPath.getArchives());
  28.317 +
  28.318 +        // add all archives to the source locations for reporting
  28.319 +        sourceLocations.addAll(archives);
  28.320 +        sourceLocations.addAll(classpaths);
  28.321 +
  28.322 +        // Work queue of names of classfiles to be searched.
  28.323 +        // Entries will be unique, and for classes that do not yet have
  28.324 +        // dependencies in the results map.
  28.325 +        Deque<String> deque = new LinkedList<String>();
  28.326 +        Set<String> doneClasses = new HashSet<String>();
  28.327 +
  28.328 +        // get the immediate dependencies of the input files
  28.329 +        for (Archive a : archives) {
  28.330 +            for (ClassFile cf : a.reader().getClassFiles()) {
  28.331 +                String classFileName;
  28.332 +                try {
  28.333 +                    classFileName = cf.getName();
  28.334 +                } catch (ConstantPoolException e) {
  28.335 +                    throw new ClassFileError(e);
  28.336 +                }
  28.337 +                a.addClass(classFileName);
  28.338 +                if (!doneClasses.contains(classFileName)) {
  28.339 +                    doneClasses.add(classFileName);
  28.340 +                }
  28.341 +                for (Dependency d : finder.findDependencies(cf)) {
  28.342 +                    if (filter.accepts(d)) {
  28.343 +                        String cn = d.getTarget().getName();
  28.344 +                        if (!doneClasses.contains(cn) && !deque.contains(cn)) {
  28.345 +                            deque.add(cn);
  28.346 +                        }
  28.347 +                        a.addDependency(d);
  28.348 +                    }
  28.349 +                }
  28.350 +            }
  28.351 +        }
  28.352 +
  28.353 +        // add Archive for looking up classes from the classpath
  28.354 +        // for transitive dependency analysis
  28.355 +        Deque<String> unresolved = roots;
  28.356 +        int depth = options.depth > 0 ? options.depth : Integer.MAX_VALUE;
  28.357 +        do {
  28.358 +            String name;
  28.359 +            while ((name = unresolved.poll()) != null) {
  28.360 +                if (doneClasses.contains(name)) {
  28.361 +                    continue;
  28.362 +                }
  28.363 +                ClassFile cf = null;
  28.364 +                for (Archive a : classpaths) {
  28.365 +                    cf = a.reader().getClassFile(name);
  28.366 +                    if (cf != null) {
  28.367 +                        String classFileName;
  28.368 +                        try {
  28.369 +                            classFileName = cf.getName();
  28.370 +                        } catch (ConstantPoolException e) {
  28.371 +                            throw new ClassFileError(e);
  28.372 +                        }
  28.373 +                        a.addClass(classFileName);
  28.374 +                        if (!doneClasses.contains(classFileName)) {
  28.375 +                            // if name is a fully-qualified class name specified
  28.376 +                            // from command-line, this class might already be parsed
  28.377 +                            doneClasses.add(classFileName);
  28.378 +                            if (depth > 0) {
  28.379 +                                for (Dependency d : finder.findDependencies(cf)) {
  28.380 +                                    if (filter.accepts(d)) {
  28.381 +                                        String cn = d.getTarget().getName();
  28.382 +                                        if (!doneClasses.contains(cn) && !deque.contains(cn)) {
  28.383 +                                            deque.add(cn);
  28.384 +                                        }
  28.385 +                                        a.addDependency(d);
  28.386 +                                    }
  28.387 +                                }
  28.388 +                            }
  28.389 +                        }
  28.390 +                        break;
  28.391 +                    }
  28.392 +                }
  28.393 +                if (cf == null) {
  28.394 +                    NOT_FOUND.addClass(name);
  28.395 +                }
  28.396 +            }
  28.397 +            unresolved = deque;
  28.398 +            deque = new LinkedList<String>();
  28.399 +        } while (!unresolved.isEmpty() && depth-- > 0);
  28.400 +    }
  28.401 +
  28.402 +    private void printPackageDeps(PrintWriter out) {
  28.403 +        for (Archive source : sourceLocations) {
  28.404 +            SortedMap<Location, SortedSet<Location>> deps = source.getDependencies();
  28.405 +            if (deps.isEmpty())
  28.406 +                continue;
  28.407 +
  28.408 +            for (Archive target : source.getRequiredArchives()) {
  28.409 +                out.format("%s -> %s%n", source, target);
  28.410 +            }
  28.411 +
  28.412 +            Map<String, Archive> pkgs = new TreeMap<String, Archive>();
  28.413 +            SortedMap<String, Archive> targets = new TreeMap<String, Archive>();
  28.414 +            String pkg = "";
  28.415 +            for (Map.Entry<Location, SortedSet<Location>> e : deps.entrySet()) {
  28.416 +                String cn = e.getKey().getClassName();
  28.417 +                String p = packageOf(e.getKey());
  28.418 +                Archive origin = Archive.find(e.getKey());
  28.419 +                assert origin != null;
  28.420 +                if (!pkgs.containsKey(p)) {
  28.421 +                    pkgs.put(p, origin);
  28.422 +                } else if (pkgs.get(p) != origin) {
  28.423 +                    warning("warn.split.package", p, origin, pkgs.get(p));
  28.424 +                }
  28.425 +
  28.426 +                if (!p.equals(pkg)) {
  28.427 +                    printTargets(out, targets);
  28.428 +                    pkg = p;
  28.429 +                    targets.clear();
  28.430 +                    out.format("   %s (%s)%n", p, origin.getFileName());
  28.431 +                }
  28.432 +
  28.433 +                for (Location t : e.getValue()) {
  28.434 +                    p = packageOf(t);
  28.435 +                    Archive target = Archive.find(t);
  28.436 +                    if (!targets.containsKey(p)) {
  28.437 +                        targets.put(p, target);
  28.438 +                    }
  28.439 +                }
  28.440 +            }
  28.441 +            printTargets(out, targets);
  28.442 +            out.println();
  28.443 +        }
  28.444 +    }
  28.445 +
  28.446 +    private void printTargets(PrintWriter out, Map<String, Archive> targets) {
  28.447 +        for (Map.Entry<String, Archive> t : targets.entrySet()) {
  28.448 +            String pn = t.getKey();
  28.449 +            out.format("      -> %-40s %s%n", pn, getPackageInfo(pn, t.getValue()));
  28.450 +        }
  28.451 +    }
  28.452 +
  28.453 +    private String getPackageInfo(String pn, Archive source) {
  28.454 +        if (PlatformClassPath.contains(source)) {
  28.455 +            String name = PlatformClassPath.getProfileName(pn);
  28.456 +            if (name.isEmpty()) {
  28.457 +                return "JDK internal API (" + source.getFileName() + ")";
  28.458 +            }
  28.459 +            return options.showProfile ? name : "";
  28.460 +        }
  28.461 +        return source.getFileName();
  28.462 +    }
  28.463 +
  28.464 +    private static String packageOf(Location loc) {
  28.465 +        String pkg = loc.getPackageName();
  28.466 +        return pkg.isEmpty() ? "<unnamed>" : pkg;
  28.467 +    }
  28.468 +
  28.469 +    private void printClassDeps(PrintWriter out) {
  28.470 +        for (Archive source : sourceLocations) {
  28.471 +            SortedMap<Location, SortedSet<Location>> deps = source.getDependencies();
  28.472 +            if (deps.isEmpty())
  28.473 +                continue;
  28.474 +
  28.475 +            for (Archive target : source.getRequiredArchives()) {
  28.476 +                out.format("%s -> %s%n", source, target);
  28.477 +            }
  28.478 +            out.format("%s%n", source);
  28.479 +            for (Map.Entry<Location, SortedSet<Location>> e : deps.entrySet()) {
  28.480 +                String cn = e.getKey().getClassName();
  28.481 +                Archive origin = Archive.find(e.getKey());
  28.482 +                out.format("   %s (%s)%n", cn, origin.getFileName());
  28.483 +                for (Location t : e.getValue()) {
  28.484 +                    cn = t.getClassName();
  28.485 +                    Archive target = Archive.find(t);
  28.486 +                    out.format("      -> %-60s %s%n", cn, getPackageInfo(t.getPackageName(), target));
  28.487 +                }
  28.488 +            }
  28.489 +            out.println();
  28.490 +        }
  28.491 +    }
  28.492 +    public void handleOptions(String[] args) throws BadArgs {
  28.493 +        // process options
  28.494 +        for (int i=0; i < args.length; i++) {
  28.495 +            if (args[i].charAt(0) == '-') {
  28.496 +                String name = args[i];
  28.497 +                Option option = getOption(name);
  28.498 +                String param = null;
  28.499 +                if (option.hasArg) {
  28.500 +                    if (name.startsWith("--") && name.indexOf('=') > 0) {
  28.501 +                        param = name.substring(name.indexOf('=') + 1, name.length());
  28.502 +                    } else if (i + 1 < args.length) {
  28.503 +                        param = args[++i];
  28.504 +                    }
  28.505 +                    if (param == null || param.isEmpty() || param.charAt(0) == '-') {
  28.506 +                        throw new BadArgs("err.missing.arg", name).showUsage(true);
  28.507 +                    }
  28.508 +                }
  28.509 +                option.process(this, name, param);
  28.510 +                if (option.ignoreRest()) {
  28.511 +                    i = args.length;
  28.512 +                }
  28.513 +            } else {
  28.514 +                // process rest of the input arguments
  28.515 +                for (; i < args.length; i++) {
  28.516 +                    String name = args[i];
  28.517 +                    if (name.charAt(0) == '-') {
  28.518 +                        throw new BadArgs("err.option.after.class", name).showUsage(true);
  28.519 +                    }
  28.520 +                    if (name.equals("*") || name.equals("\"*\"")) {
  28.521 +                        options.wildcard = true;
  28.522 +                    } else {
  28.523 +                        classes.add(name);
  28.524 +                    }
  28.525 +                }
  28.526 +            }
  28.527 +        }
  28.528 +    }
  28.529 +
  28.530 +    private Option getOption(String name) throws BadArgs {
  28.531 +        for (Option o : recognizedOptions) {
  28.532 +            if (o.matches(name)) {
  28.533 +                return o;
  28.534 +            }
  28.535 +        }
  28.536 +        throw new BadArgs("err.unknown.option", name).showUsage(true);
  28.537 +    }
  28.538 +
  28.539 +    private void reportError(String key, Object... args) {
  28.540 +        log.println(getMessage("error.prefix") + " " + getMessage(key, args));
  28.541 +    }
  28.542 +
  28.543 +    private void warning(String key, Object... args) {
  28.544 +        log.println(getMessage("warn.prefix") + " " + getMessage(key, args));
  28.545 +    }
  28.546 +
  28.547 +    private void showHelp() {
  28.548 +        log.println(getMessage("main.usage", PROGNAME));
  28.549 +        for (Option o : recognizedOptions) {
  28.550 +            String name = o.aliases[0].substring(1); // there must always be at least one name
  28.551 +            name = name.charAt(0) == '-' ? name.substring(1) : name;
  28.552 +            if (o.isHidden() || name.equals("h")) {
  28.553 +                continue;
  28.554 +            }
  28.555 +            log.println(getMessage("main.opt." + name));
  28.556 +        }
  28.557 +    }
  28.558 +
  28.559 +    private void showVersion(boolean full) {
  28.560 +        log.println(version(full ? "full" : "release"));
  28.561 +    }
  28.562 +
  28.563 +    private String version(String key) {
  28.564 +        // key=version:  mm.nn.oo[-milestone]
  28.565 +        // key=full:     mm.mm.oo[-milestone]-build
  28.566 +        if (ResourceBundleHelper.versionRB == null) {
  28.567 +            return System.getProperty("java.version");
  28.568 +        }
  28.569 +        try {
  28.570 +            return ResourceBundleHelper.versionRB.getString(key);
  28.571 +        } catch (MissingResourceException e) {
  28.572 +            return getMessage("version.unknown", System.getProperty("java.version"));
  28.573 +        }
  28.574 +    }
  28.575 +
  28.576 +    public String getMessage(String key, Object... args) {
  28.577 +        try {
  28.578 +            return MessageFormat.format(ResourceBundleHelper.bundle.getString(key), args);
  28.579 +        } catch (MissingResourceException e) {
  28.580 +            throw new InternalError("Missing message: " + key);
  28.581 +        }
  28.582 +    }
  28.583 +
  28.584 +    private static class Options {
  28.585 +        enum Verbose {
  28.586 +            CLASS,
  28.587 +            PACKAGE,
  28.588 +            SUMMARY,
  28.589 +            VERBOSE
  28.590 +        };
  28.591 +
  28.592 +        boolean help;
  28.593 +        boolean version;
  28.594 +        boolean fullVersion;
  28.595 +        boolean showFlags;
  28.596 +        boolean showProfile;
  28.597 +        boolean showSummary;
  28.598 +        boolean wildcard;
  28.599 +        String regex;
  28.600 +        String classpath = "";
  28.601 +        int depth = 1;
  28.602 +        Verbose verbose = Verbose.PACKAGE;
  28.603 +        Set<String> packageNames = new HashSet<String>();
  28.604 +    }
  28.605 +
  28.606 +    private static class ResourceBundleHelper {
  28.607 +        static final ResourceBundle versionRB;
  28.608 +        static final ResourceBundle bundle;
  28.609 +
  28.610 +        static {
  28.611 +            Locale locale = Locale.getDefault();
  28.612 +            try {
  28.613 +                bundle = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.jdeps", locale);
  28.614 +            } catch (MissingResourceException e) {
  28.615 +                throw new InternalError("Cannot find jdeps resource bundle for locale " + locale);
  28.616 +            }
  28.617 +            try {
  28.618 +                versionRB = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.version");
  28.619 +            } catch (MissingResourceException e) {
  28.620 +                throw new InternalError("version.resource.missing");
  28.621 +            }
  28.622 +        }
  28.623 +    }
  28.624 +
  28.625 +    private List<Archive> getArchives(List<String> filenames) throws IOException {
  28.626 +        List<Archive> result = new ArrayList<Archive>();
  28.627 +        for (String s : filenames) {
  28.628 +            File f = new File(s);
  28.629 +            if (f.exists()) {
  28.630 +                result.add(new Archive(f, ClassFileReader.newInstance(f)));
  28.631 +            } else {
  28.632 +                warning("warn.file.not.exist", s);
  28.633 +            }
  28.634 +        }
  28.635 +        return result;
  28.636 +    }
  28.637 +
  28.638 +    private List<Archive> getClassPathArchives(String paths) throws IOException {
  28.639 +        List<Archive> result = new ArrayList<Archive>();
  28.640 +        if (paths.isEmpty()) {
  28.641 +            return result;
  28.642 +        }
  28.643 +        for (String p : paths.split(File.pathSeparator)) {
  28.644 +            if (p.length() > 0) {
  28.645 +                File f = new File(p);
  28.646 +                if (f.exists()) {
  28.647 +                    result.add(new Archive(f, ClassFileReader.newInstance(f)));
  28.648 +                }
  28.649 +            }
  28.650 +        }
  28.651 +        return result;
  28.652 +    }
  28.653 +}

    29.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    29.2 +++ b/src/share/classes/com/sun/tools/jdeps/Main.java	Thu Jan 10 15:53:02 2013 -0800
    29.3 @@ -0,0 +1,66 @@
    29.4 +/*
    29.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    29.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    29.7 + *
    29.8 + * This code is free software; you can redistribute it and/or modify it
    29.9 + * under the terms of the GNU General Public License version 2 only, as
   29.10 + * published by the Free Software Foundation.  Oracle designates this
   29.11 + * particular file as subject to the "Classpath" exception as provided
   29.12 + * by Oracle in the LICENSE file that accompanied this code.
   29.13 + *
   29.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   29.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   29.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   29.17 + * version 2 for more details (a copy is included in the LICENSE file that
   29.18 + * accompanied this code).
   29.19 + *
   29.20 + * You should have received a copy of the GNU General Public License version
   29.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   29.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   29.23 + *
   29.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   29.25 + * or visit www.oracle.com if you need additional information or have any
   29.26 + * questions.
   29.27 + */
   29.28 +
   29.29 +package com.sun.tools.jdeps;
   29.30 +
   29.31 +import java.io.*;
   29.32 +
   29.33 +/**
   29.34 + *
   29.35 + * Usage:
   29.36 + *    jdeps [options] files ...
   29.37 + * where options include:
   29.38 + *    -p package-name   restrict analysis to classes in this package
   29.39 + *                      (may be given multiple times)
   29.40 + *    -e regex          restrict analysis to packages matching pattern
   29.41 + *                      (-p and -e are exclusive)
   29.42 + *    -v                show class-level dependencies
   29.43 + *                      default: package-level dependencies
   29.44 + *    -r --recursive    transitive dependencies analysis
   29.45 + *    -classpath paths  Classpath to locate class files
   29.46 + *    -all              process all class files in the given classpath
   29.47 + */
   29.48 +public class Main {
   29.49 +    public static void main(String... args) throws Exception {
   29.50 +        JdepsTask t = new JdepsTask();
   29.51 +        int rc = t.run(args);
   29.52 +        System.exit(rc);
   29.53 +    }
   29.54 +
   29.55 +
   29.56 +    /**
   29.57 +     * Entry point that does <i>not</i> call System.exit.
   29.58 +     *
   29.59 +     * @param args command line arguments
   29.60 +     * @param out output stream
   29.61 +     * @return an exit code. 0 means success, non-zero means an error occurred.
   29.62 +     */
   29.63 +    public static int run(String[] args, PrintWriter out) {
   29.64 +        JdepsTask t = new JdepsTask();
   29.65 +        t.setLog(out);
   29.66 +        return t.run(args);
   29.67 +    }
   29.68 +}
   29.69 +

    30.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    30.2 +++ b/src/share/classes/com/sun/tools/jdeps/PlatformClassPath.java	Thu Jan 10 15:53:02 2013 -0800
    30.3 @@ -0,0 +1,169 @@
    30.4 +/*
    30.5 + * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    30.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    30.7 + *
    30.8 + * This code is free software; you can redistribute it and/or modify it
    30.9 + * under the terms of the GNU General Public License version 2 only, as
   30.10 + * published by the Free Software Foundation.  Oracle designates this
   30.11 + * particular file as subject to the "Classpath" exception as provided
   30.12 + * by Oracle in the LICENSE file that accompanied this code.
   30.13 + *
   30.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   30.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   30.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   30.17 + * version 2 for more details (a copy is included in the LICENSE file that
   30.18 + * accompanied this code).
   30.19 + *
   30.20 + * You should have received a copy of the GNU General Public License version
   30.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   30.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   30.23 + *
   30.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   30.25 + * or visit www.oracle.com if you need additional information or have any
   30.26 + * questions.
   30.27 + */
   30.28 +package com.sun.tools.jdeps;
   30.29 +
   30.30 +import java.io.File;
   30.31 +import java.io.IOException;
   30.32 +import java.nio.file.FileVisitResult;
   30.33 +import java.nio.file.Files;
   30.34 +import java.nio.file.Path;
   30.35 +import java.nio.file.SimpleFileVisitor;
   30.36 +import java.nio.file.attribute.BasicFileAttributes;
   30.37 +import java.util.*;
   30.38 +
   30.39 +/**
   30.40 + * ClassPath for Java SE and JDK
   30.41 + */
   30.42 +class PlatformClassPath {
   30.43 +    /*
   30.44 +     * Profiles for Java SE
   30.45 +     *
   30.46 +     * This is a temporary workaround until a common API is defined for langtools
   30.47 +     * to determine which profile a given classname belongs to.  The list of
   30.48 +     * packages and profile names are hardcoded in jdk.properties and
   30.49 +     * split packages are not supported.
   30.50 +     */
   30.51 +    static class Profile {
   30.52 +        final String name;
   30.53 +        final Set<String> packages;
   30.54 +
   30.55 +        Profile(String name) {
   30.56 +            this.name = name;
   30.57 +            this.packages = new HashSet<String>();
   30.58 +        }
   30.59 +    }
   30.60 +
   30.61 +    private final static String JAVAFX = "javafx";
   30.62 +    private final static Map<String,Profile> map = getProfilePackages();
   30.63 +    static String getProfileName(String packageName) {
   30.64 +        Profile profile = map.get(packageName);
   30.65 +        if (packageName.startsWith(JAVAFX + ".")) {
   30.66 +            profile = map.get(JAVAFX);
   30.67 +        }
   30.68 +        return profile != null ? profile.name : "";
   30.69 +    }
   30.70 +
   30.71 +    private final static List<Archive> javaHomeArchives = init();
   30.72 +    static List<Archive> getArchives() {
   30.73 +        return javaHomeArchives;
   30.74 +    }
   30.75 +
   30.76 +    static boolean contains(Archive archive) {
   30.77 +        return javaHomeArchives.contains(archive);
   30.78 +    }
   30.79 +
   30.80 +    private static List<Archive> init() {
   30.81 +        List<Archive> result = new ArrayList<Archive>();
   30.82 +        String javaHome = System.getProperty("java.home");
   30.83 +        List<File> files = new ArrayList<File>();
   30.84 +        File jre = new File(javaHome, "jre");
   30.85 +        File lib = new File(javaHome, "lib");
   30.86 +
   30.87 +        try {
   30.88 +            if (jre.exists() && jre.isDirectory()) {
   30.89 +                result.addAll(addJarFiles(new File(jre, "lib")));
   30.90 +                result.addAll(addJarFiles(lib));
   30.91 +            } else if (lib.exists() && lib.isDirectory()) {
   30.92 +                // either a JRE or a jdk build image
   30.93 +                File classes = new File(javaHome, "classes");
   30.94 +                if (classes.exists() && classes.isDirectory()) {
   30.95 +                    // jdk build outputdir
   30.96 +                    result.add(new Archive(classes, ClassFileReader.newInstance(classes)));
   30.97 +                }
   30.98 +                // add other JAR files
   30.99 +                result.addAll(addJarFiles(lib));
  30.100 +            } else {
  30.101 +                throw new RuntimeException("\"" + javaHome + "\" not a JDK home");
  30.102 +            }
  30.103 +        } catch (IOException e) {
  30.104 +            throw new RuntimeException(e);
  30.105 +        }
  30.106 +
  30.107 +        // add a JavaFX profile if there is jfxrt.jar
  30.108 +        for (Archive archive : result) {
  30.109 +            if (archive.getFileName().equals("jfxrt.jar")) {
  30.110 +                map.put(JAVAFX, new Profile("jfxrt.jar"));
  30.111 +            }
  30.112 +        }
  30.113 +        return result;
  30.114 +    }
  30.115 +
  30.116 +    private static List<Archive> addJarFiles(File f) throws IOException {
  30.117 +        final List<Archive> result = new ArrayList<Archive>();
  30.118 +        final Path root = f.toPath();
  30.119 +        final Path ext = root.resolve("ext");
  30.120 +        Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
  30.121 +            @Override
  30.122 +            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
  30.123 +                throws IOException
  30.124 +            {
  30.125 +                if (dir.equals(root) || dir.equals(ext)) {
  30.126 +                    return FileVisitResult.CONTINUE;
  30.127 +                } else {
  30.128 +                    // skip other cobundled JAR files
  30.129 +                    return FileVisitResult.SKIP_SUBTREE;
  30.130 +                }
  30.131 +            }
  30.132 +            @Override
  30.133 +            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
  30.134 +                throws IOException
  30.135 +            {
  30.136 +                File f = file.toFile();
  30.137 +                String fn = f.getName();
  30.138 +                if (fn.endsWith(".jar") && !fn.equals("alt-rt.jar")) {
  30.139 +                    result.add(new Archive(f, ClassFileReader.newInstance(f)));
  30.140 +                }
  30.141 +                return FileVisitResult.CONTINUE;
  30.142 +            }
  30.143 +        });
  30.144 +        return result;
  30.145 +    }
  30.146 +
  30.147 +    private static Map<String,Profile> getProfilePackages() {
  30.148 +        Map<String,Profile> map = new HashMap<String,Profile>();
  30.149 +
  30.150 +        // read the properties as a ResourceBundle as the build compiles
  30.151 +        // the properties file into Java class.  Another alternative is
  30.152 +        // to load it as Properties and fix the build to exclude this file.
  30.153 +        ResourceBundle profileBundle =
  30.154 +            ResourceBundle.getBundle("com.sun.tools.jdeps.resources.jdk");
  30.155 +
  30.156 +        int i=1;
  30.157 +        String key;
  30.158 +        while (profileBundle.containsKey((key = "profile." + i + ".name"))) {
  30.159 +            Profile profile = new Profile(profileBundle.getString(key));
  30.160 +            String n = profileBundle.getString("profile." + i + ".packages");
  30.161 +            String[] pkgs = n.split("\\s+");
  30.162 +            for (String p : pkgs) {
  30.163 +                if (p.isEmpty()) continue;
  30.164 +                assert(map.containsKey(p) == false);
  30.165 +                profile.packages.add(p);
  30.166 +                map.put(p, profile);
  30.167 +            }
  30.168 +            i++;
  30.169 +        }
  30.170 +        return map;
  30.171 +    }
  30.172 +}

    31.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    31.2 +++ b/src/share/classes/com/sun/tools/jdeps/resources/jdeps.properties	Thu Jan 10 15:53:02 2013 -0800
    31.3 @@ -0,0 +1,57 @@
    31.4 +main.usage.summary=\
    31.5 +Usage: {0} <options> <classes...>\n\
    31.6 +use -h, -? or --help for a list of possible options
    31.7 +
    31.8 +main.usage=\
    31.9 +Usage: {0} <options> <classes...>\n\
   31.10 +where <classes> can be a pathname to a .class file, a directory, a JAR file,\n\
   31.11 +or a fully-qualified classname or wildcard "*".  Possible options include:
   31.12 +
   31.13 +error.prefix=Error:
   31.14 +warn.prefix=Warning:
   31.15 +
   31.16 +main.opt.h=\
   31.17 +\  -h -?      --help                    Print this usage message
   31.18 +
   31.19 +main.opt.version=\
   31.20 +\             --version                 Version information
   31.21 +
   31.22 +main.opt.V=\
   31.23 +\  -V <level> --verbose-level=<level>   Print package-level or class-level dependencies\n\
   31.24 +\                                       Valid levels are: "package" and "class"
   31.25 +
   31.26 +main.opt.v=\
   31.27 +\  -v         --verbose                 Print additional information
   31.28 +
   31.29 +main.opt.s=\
   31.30 +\  -s         --summary                 Print dependency summary only
   31.31 +
   31.32 +main.opt.p=\
   31.33 +\  -p <pkg name> --package=<pkg name>   Restrict analysis to classes in this package\n\
   31.34 +\                                       (may be given multiple times)
   31.35 +
   31.36 +main.opt.e=\
   31.37 +\  -e <regex> --regex=<regex>           Restrict analysis to packages matching pattern\n\
   31.38 +\                                       (-p and -e are exclusive)
   31.39 +
   31.40 +main.opt.P=\
   31.41 +\  -P         --profile                 Show profile or the file containing a package
   31.42 +
   31.43 +main.opt.c=\
   31.44 +\  -c <path>  --classpath=<path>        Specify where to find class files
   31.45 +
   31.46 +main.opt.R=\
   31.47 +\  -R         --recursive               Recursively traverse all dependencies
   31.48 +
   31.49 +main.opt.d=\
   31.50 +\  -d <depth> --depth=<depth>           Specify the depth of the transitive dependency analysis
   31.51 +
   31.52 +err.unknown.option=unknown option: {0}
   31.53 +err.missing.arg=no value given for {0}
   31.54 +err.internal.error=internal error: {0} {1} {2}
   31.55 +err.invalid.arg.for.option=invalid argument for option: {0}
   31.56 +err.option.after.class=option must be specified before classes: {0}
   31.57 +warn.invalid.arg=Invalid classname or pathname not exist: {0}
   31.58 +warn.split.package=package {0} defined in {1} {2}
   31.59 +
   31.60 +artifact.not.found=not found

    32.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    32.2 +++ b/src/share/classes/com/sun/tools/jdeps/resources/jdk.properties	Thu Jan 10 15:53:02 2013 -0800
    32.3 @@ -0,0 +1,262 @@
    32.4 +# This properties file does not need localization.
    32.5 +
    32.6 +profile.1.name = compact1
    32.7 +profile.1.packages = \
    32.8 +    java.io \
    32.9 +    java.lang \
   32.10 +    java.lang.annotation \
   32.11 +    java.lang.invoke \
   32.12 +    java.lang.ref \
   32.13 +    java.lang.reflect \
   32.14 +    java.math \
   32.15 +    java.net \
   32.16 +    java.nio \
   32.17 +    java.nio.channels \
   32.18 +    java.nio.channels.spi \
   32.19 +    java.nio.charset \
   32.20 +    java.nio.charset.spi \
   32.21 +    java.nio.file \
   32.22 +    java.nio.file.attribute \
   32.23 +    java.nio.file.spi \
   32.24 +    java.security \
   32.25 +    java.security.cert \
   32.26 +    java.security.interfaces \
   32.27 +    java.security.spec \
   32.28 +    java.text \
   32.29 +    java.text.spi \
   32.30 +    java.util \
   32.31 +    java.util.concurrent \
   32.32 +    java.util.concurrent.atomic \
   32.33 +    java.util.concurrent.locks \
   32.34 +    java.util.jar \
   32.35 +    java.util.logging \
   32.36 +    java.util.regex \
   32.37 +    java.util.spi \
   32.38 +    java.util.zip \
   32.39 +    javax.crypto \
   32.40 +    javax.crypto.interfaces \
   32.41 +    javax.crypto.spec \
   32.42 +    javax.security.auth \
   32.43 +    javax.security.auth.callback \
   32.44 +    javax.security.auth.login \
   32.45 +    javax.security.auth.spi \
   32.46 +    javax.security.auth.x500 \
   32.47 +    javax.net \
   32.48 +    javax.net.ssl \
   32.49 +    javax.security.cert \
   32.50 +    \
   32.51 +    com.sun.net.ssl \
   32.52 +    com.sun.nio.file \
   32.53 +    com.sun.nio.sctp \
   32.54 +    com.sun.security.auth \
   32.55 +    com.sun.security.auth.login
   32.56 +
   32.57 +profile.2.name = compact2
   32.58 +profile.2.packages = \
   32.59 +    java.sql \
   32.60 +    javax.sql \
   32.61 +    javax.xml \
   32.62 +    javax.xml.datatype \
   32.63 +    javax.xml.namespace \
   32.64 +    javax.xml.parsers \
   32.65 +    javax.xml.stream \
   32.66 +    javax.xml.stream.events \
   32.67 +    javax.xml.stream.util \
   32.68 +    javax.xml.transform \
   32.69 +    javax.xml.transform.dom \
   32.70 +    javax.xml.transform.sax \
   32.71 +    javax.xml.transform.stax \
   32.72 +    javax.xml.transform.stream \
   32.73 +    javax.xml.validation \
   32.74 +    javax.xml.xpath \
   32.75 +    org.w3c.dom \
   32.76 +    org.w3c.dom.bootstrap \
   32.77 +    org.w3c.dom.events \
   32.78 +    org.w3c.dom.ls \
   32.79 +    org.xml.sax \
   32.80 +    org.xml.sax.ext \
   32.81 +    org.xml.sax.helpers \
   32.82 +    java.rmi \
   32.83 +    java.rmi.activation \
   32.84 +    java.rmi.dgc \
   32.85 +    java.rmi.registry \
   32.86 +    java.rmi.server \
   32.87 +    javax.rmi.ssl \
   32.88 +    javax.transaction \
   32.89 +    javax.transaction.xa \
   32.90 +    \
   32.91 +    com.sun.net.httpserver \
   32.92 +    com.sun.net.httpserver.spi
   32.93 +
   32.94 +profile.3.name = compact3
   32.95 +profile.3.packages = \
   32.96 +    java.lang.instrument \
   32.97 +    java.lang.management \
   32.98 +    java.security.acl \
   32.99 +    java.util.prefs \
  32.100 +    javax.management \
  32.101 +    javax.management.loading \
  32.102 +    javax.management.modelmbean \
  32.103 +    javax.management.monitor \
  32.104 +    javax.management.openmbean \
  32.105 +    javax.management.relation \
  32.106 +    javax.management.remote \
  32.107 +    javax.management.remote.rmi \
  32.108 +    javax.management.timer \
  32.109 +    javax.naming \
  32.110 +    javax.naming.directory \
  32.111 +    javax.naming.event \
  32.112 +    javax.naming.ldap \
  32.113 +    javax.naming.spi \
  32.114 +    javax.sql.rowset \
  32.115 +    javax.sql.rowset.serial \
  32.116 +    javax.sql.rowset.spi \
  32.117 +    javax.security.auth.kerberos \
  32.118 +    javax.security.sasl \
  32.119 +    javax.script \
  32.120 +    javax.smartcardio \
  32.121 +    javax.xml.crypto \
  32.122 +    javax.xml.crypto.dom \
  32.123 +    javax.xml.crypto.dsig \
  32.124 +    javax.xml.crypto.dsig.dom \
  32.125 +    javax.xml.crypto.dsig.keyinfo \
  32.126 +    javax.xml.crypto.dsig.spec \
  32.127 +    javax.annotation.processing \
  32.128 +    javax.lang.model \
  32.129 +    javax.lang.model.element \
  32.130 +    javax.lang.model.type \
  32.131 +    javax.lang.model.util \
  32.132 +    javax.tools \
  32.133 +    javax.tools.annotation \
  32.134 +    org.ietf.jgss \
  32.135 +    \
  32.136 +    com.sun.management \
  32.137 +    com.sun.security.auth.callback \
  32.138 +    com.sun.security.auth.module \
  32.139 +    com.sun.security.jgss
  32.140 +
  32.141 +profile.4.name = Full JRE
  32.142 +profile.4.packages = \
  32.143 +    java.applet \
  32.144 +    java.awt \
  32.145 +    java.awt.color \
  32.146 +    java.awt.datatransfer \
  32.147 +    java.awt.dnd \
  32.148 +    java.awt.dnd.peer \
  32.149 +    java.awt.event \
  32.150 +    java.awt.font \
  32.151 +    java.awt.geom \
  32.152 +    java.awt.im \
  32.153 +    java.awt.im.spi \
  32.154 +    java.awt.image \
  32.155 +    java.awt.image.renderable \
  32.156 +    java.awt.peer \
  32.157 +    java.awt.print \
  32.158 +    java.beans \
  32.159 +    java.beans.beancontext \
  32.160 +    javax.accessibility \
  32.161 +    javax.imageio \
  32.162 +    javax.imageio.event \
  32.163 +    javax.imageio.metadata \
  32.164 +    javax.imageio.plugins.bmp \
  32.165 +    javax.imageio.plugins.jpeg \
  32.166 +    javax.imageio.spi \
  32.167 +    javax.imageio.stream \
  32.168 +    javax.print \
  32.169 +    javax.print.attribute \
  32.170 +    javax.print.attribute.standard \
  32.171 +    javax.print.event \
  32.172 +    javax.sound.midi \
  32.173 +    javax.sound.midi.spi \
  32.174 +    javax.sound.sampled \
  32.175 +    javax.sound.sampled.spi \
  32.176 +    javax.swing \
  32.177 +    javax.swing.border \
  32.178 +    javax.swing.colorchooser \
  32.179 +    javax.swing.event \
  32.180 +    javax.swing.filechooser \
  32.181 +    javax.swing.plaf \
  32.182 +    javax.swing.plaf.basic \
  32.183 +    javax.swing.plaf.metal \
  32.184 +    javax.swing.plaf.multi \
  32.185 +    javax.swing.plaf.nimbus \
  32.186 +    javax.swing.plaf.synth \
  32.187 +    javax.swing.table \
  32.188 +    javax.swing.text \
  32.189 +    javax.swing.text.html \
  32.190 +    javax.swing.text.html.parser \
  32.191 +    javax.swing.text.rtf \
  32.192 +    javax.swing.tree \
  32.193 +    javax.swing.undo \
  32.194 +    javax.activation \
  32.195 +    javax.jws \
  32.196 +    javax.jws.soap \
  32.197 +    javax.rmi \
  32.198 +    javax.rmi.CORBA \
  32.199 +    javax.xml.bind \
  32.200 +    javax.xml.bind.annotation \
  32.201 +    javax.xml.bind.annotation.adapters \
  32.202 +    javax.xml.bind.attachment \
  32.203 +    javax.xml.bind.helpers \
  32.204 +    javax.xml.bind.util \
  32.205 +    javax.xml.soap \
  32.206 +    javax.xml.ws \
  32.207 +    javax.xml.ws.handler \
  32.208 +    javax.xml.ws.handler.soap \
  32.209 +    javax.xml.ws.http \
  32.210 +    javax.xml.ws.soap \
  32.211 +    javax.xml.ws.spi \
  32.212 +    javax.xml.ws.spi.http \
  32.213 +    javax.xml.ws.wsaddressing \
  32.214 +    javax.annotation \
  32.215 +    org.omg.CORBA \
  32.216 +    org.omg.CORBA.DynAnyPackage \
  32.217 +    org.omg.CORBA.ORBPackage \
  32.218 +    org.omg.CORBA.TypeCodePackage \
  32.219 +    org.omg.CORBA.portable \
  32.220 +    org.omg.CORBA_2_3 \
  32.221 +    org.omg.CORBA_2_3.portable \
  32.222 +    org.omg.CosNaming \
  32.223 +    org.omg.CosNaming.NamingContextExtPackage \
  32.224 +    org.omg.CosNaming.NamingContextPackage \
  32.225 +    org.omg.Dynamic \
  32.226 +    org.omg.DynamicAny \
  32.227 +    org.omg.DynamicAny.DynAnyFactoryPackage \
  32.228 +    org.omg.DynamicAny.DynAnyPackage \
  32.229 +    org.omg.IOP \
  32.230 +    org.omg.IOP.CodecFactoryPackage \
  32.231 +    org.omg.IOP.CodecPackage \
  32.232 +    org.omg.Messaging \
  32.233 +    org.omg.PortableInterceptor \
  32.234 +    org.omg.PortableInterceptor.ORBInitInfoPackage \
  32.235 +    org.omg.PortableServer \
  32.236 +    org.omg.PortableServer.CurrentPackage \
  32.237 +    org.omg.PortableServer.POAManagerPackage \
  32.238 +    org.omg.PortableServer.POAPackage \
  32.239 +    org.omg.PortableServer.ServantLocatorPackage \
  32.240 +    org.omg.PortableServer.portable \
  32.241 +    org.omg.SendingContext \
  32.242 +    org.omg.stub.java.rmi \
  32.243 +    org.omg.stub.javax.management.remote.rmi
  32.244 +
  32.245 +# Remaining JDK supported API
  32.246 +profile.5.name = JDK tools
  32.247 +profile.5.packages = \
  32.248 +    com.sun.jdi \
  32.249 +    com.sun.jdi.connect \
  32.250 +    com.sun.jdi.connect.spi \
  32.251 +    com.sun.jdi.event \
  32.252 +    com.sun.jdi.request \
  32.253 +    com.sun.javadoc \
  32.254 +    com.sun.tools.doclets \
  32.255 +    com.sun.tools.doctree \
  32.256 +    com.sun.source.tree \
  32.257 +    com.sun.source.util \
  32.258 +    com.sun.tools.attach \
  32.259 +    com.sun.tools.attach.spi \
  32.260 +    com.sun.tools.jconsole \
  32.261 +    com.sun.tools.javac \
  32.262 +    com.sun.tools.javah \
  32.263 +    com.sun.tools.javap \
  32.264 +    com.sun.tools.javadoc \
  32.265 +    com.sun.servicetag

    33.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    33.2 +++ b/src/share/classes/com/sun/tools/jdeps/resources/version.properties-template	Thu Jan 10 15:53:02 2013 -0800
    33.3 @@ -0,0 +1,28 @@
    33.4 +#
    33.5 +# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
    33.6 +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    33.7 +#
    33.8 +# This code is free software; you can redistribute it and/or modify it
    33.9 +# under the terms of the GNU General Public License version 2 only, as
   33.10 +# published by the Free Software Foundation.  Oracle designates this
   33.11 +# particular file as subject to the "Classpath" exception as provided
   33.12 +# by Oracle in the LICENSE file that accompanied this code.
   33.13 +#
   33.14 +# This code is distributed in the hope that it will be useful, but WITHOUT
   33.15 +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   33.16 +# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   33.17 +# version 2 for more details (a copy is included in the LICENSE file that
   33.18 +# accompanied this code).
   33.19 +#
   33.20 +# You should have received a copy of the GNU General Public License version
   33.21 +# 2 along with this work; if not, write to the Free Software Foundation,
   33.22 +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   33.23 +#
   33.24 +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   33.25 +# or visit www.oracle.com if you need additional information or have any
   33.26 +# questions.
   33.27 +#
   33.28 +
   33.29 +jdk=$(JDK_VERSION)
   33.30 +full=$(FULL_VERSION)
   33.31 +release=$(RELEASE)

    34.1 --- a/src/share/classes/javax/lang/model/element/Element.java	Thu Jan 10 09:56:09 2013 -0800
    34.2 +++ b/src/share/classes/javax/lang/model/element/Element.java	Thu Jan 10 15:53:02 2013 -0800
    34.3 @@ -179,6 +179,10 @@
    34.4       * instance initializer}, an empty name is returned.
    34.5       *
    34.6       * @return the simple name of this element
    34.7 +     * @see PackageElement#getSimpleName
    34.8 +     * @see ExecutableElement#getSimpleName
    34.9 +     * @see TypeElement#getSimpleName
   34.10 +     * @see VariableElement#getSimpleName
   34.11       */
   34.12      Name getSimpleName();
   34.13  
   34.14 @@ -202,6 +206,11 @@
   34.15       * {@linkplain TypeParameterElement#getGenericElement the
   34.16       * generic element} of the type parameter is returned.
   34.17       *
   34.18 +     * <li> If this is a {@linkplain
   34.19 +     * VariableElement#getEnclosingElement method or constructor
   34.20 +     * parameter}, {@linkplain ExecutableElement the executable
   34.21 +     * element} which declares the parameter is returned.
   34.22 +     *
   34.23       * </ul>
   34.24       *
   34.25       * @return the enclosing element, or {@code null} if there is none

    35.1 --- a/src/share/classes/javax/lang/model/element/VariableElement.java	Thu Jan 10 09:56:09 2013 -0800
    35.2 +++ b/src/share/classes/javax/lang/model/element/VariableElement.java	Thu Jan 10 15:53:02 2013 -0800
    35.3 @@ -62,4 +62,29 @@
    35.4       * @jls 4.12.4 final Variables
    35.5       */
    35.6      Object getConstantValue();
    35.7 +
    35.8 +    /**
    35.9 +     * Returns the simple name of this variable element.
   35.10 +     *
   35.11 +     * <p>For method and constructor parameters, the name of each
   35.12 +     * parameter must be distinct from the names of all other
   35.13 +     * parameters of the same executable.  If the original source
   35.14 +     * names are not available, an implementation may synthesize names
   35.15 +     * subject to the distinctness requirement above.
   35.16 +     *
   35.17 +     * @return the simple name of this variable element
   35.18 +     */
   35.19 +    @Override
   35.20 +    Name getSimpleName();
   35.21 +
   35.22 +    /**
   35.23 +     * Returns the enclosing element of this variable.
   35.24 +     *
   35.25 +     * The enclosing element of a method or constructor parameter is
   35.26 +     * the executable declaring the parameter.
   35.27 +     *
   35.28 +     * @return the enclosing element of this variable
   35.29 +     */
   35.30 +    @Override
   35.31 +    Element getEnclosingElement();
   35.32  }