Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/src/share/classes/com/sun/tools/classfile/ClassWriter.java	Tue May 14 13:55:35 2013 -0700
     1.2 +++ b/src/share/classes/com/sun/tools/classfile/ClassWriter.java	Tue May 14 15:04:06 2013 -0700
     1.3 @@ -751,7 +751,7 @@
     1.4                  break;
     1.5              // exception parameter
     1.6              case EXCEPTION_PARAMETER:
     1.7 -                out.writeByte(p.exception_index);
     1.8 +                out.writeShort(p.exception_index);
     1.9                  break;
    1.10              // method receiver
    1.11              case METHOD_RECEIVER:
    1.12 @@ -770,11 +770,11 @@
    1.13                  break;
    1.14              // class extends or implements clause
    1.15              case CLASS_EXTENDS:
    1.16 -                out.writeByte(p.type_index);
    1.17 +                out.writeShort(p.type_index);
    1.18                  break;
    1.19              // throws
    1.20              case THROWS:
    1.21 -                out.writeByte(p.type_index);
    1.22 +                out.writeShort(p.type_index);
    1.23                  break;
    1.24              // method parameter
    1.25              case METHOD_FORMAL_PARAMETER:

     2.1 --- a/src/share/classes/com/sun/tools/classfile/TypeAnnotation.java	Tue May 14 13:55:35 2013 -0700
     2.2 +++ b/src/share/classes/com/sun/tools/classfile/TypeAnnotation.java	Tue May 14 15:04:06 2013 -0700
     2.3 @@ -111,7 +111,7 @@
     2.4              break;
     2.5          // exception parameter
     2.6          case EXCEPTION_PARAMETER:
     2.7 -            position.exception_index = cr.readUnsignedByte();
     2.8 +            position.exception_index = cr.readUnsignedShort();
     2.9              break;
    2.10          // method receiver
    2.11          case METHOD_RECEIVER:
    2.12 @@ -198,7 +198,7 @@
    2.13              break;
    2.14          // exception parameter
    2.15          case EXCEPTION_PARAMETER:
    2.16 -            n += 1; // exception_index
    2.17 +            n += 2; // exception_index
    2.18              break;
    2.19          // method receiver
    2.20          case METHOD_RECEIVER:

     3.1 --- a/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java	Tue May 14 13:55:35 2013 -0700
     3.2 +++ b/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java	Tue May 14 15:04:06 2013 -0700
     3.3 @@ -1726,7 +1726,7 @@
     3.4          return text;
     3.5      }
     3.6  
     3.7 -    static Set<String> blockTags = new HashSet<String>();
     3.8 +    static final Set<String> blockTags = new HashSet<String>();
     3.9      static {
    3.10          for (HtmlTag t: HtmlTag.values()) {
    3.11              if (t.blockType == HtmlTag.BlockType.BLOCK)
    3.12 @@ -1771,7 +1771,7 @@
    3.13          return result.toString();
    3.14      }
    3.15  
    3.16 -    private static final boolean isHtmlTagLetterOrDigit(char ch) {
    3.17 +    private static boolean isHtmlTagLetterOrDigit(char ch) {
    3.18          return ('a' <= ch && ch <= 'z') ||
    3.19                  ('A' <= ch && ch <= 'Z') ||
    3.20                  ('1' <= ch && ch <= '6');

     4.1 --- a/src/share/classes/com/sun/tools/javac/code/Annotations.java	Tue May 14 13:55:35 2013 -0700
     4.2 +++ b/src/share/classes/com/sun/tools/javac/code/Annotations.java	Tue May 14 15:04:06 2013 -0700
     4.3 @@ -76,11 +76,24 @@
     4.4      private List<Attribute.Compound> attributes = DECL_NOT_STARTED;
     4.5  
     4.6      /*
     4.7 -     * This field should never be null
     4.8 +     * Type attributes for this symbol.
     4.9 +     * This field should never be null.
    4.10       */
    4.11      private List<Attribute.TypeCompound> type_attributes = List.<Attribute.TypeCompound>nil();
    4.12  
    4.13      /*
    4.14 +     * Type attributes of initializers in this class.
    4.15 +     * Unused if the current symbol is not a ClassSymbol.
    4.16 +     */
    4.17 +    private List<Attribute.TypeCompound> init_type_attributes = List.<Attribute.TypeCompound>nil();
    4.18 +
    4.19 +    /*
    4.20 +     * Type attributes of class initializers in this class.
    4.21 +     * Unused if the current symbol is not a ClassSymbol.
    4.22 +     */
    4.23 +    private List<Attribute.TypeCompound> clinit_type_attributes = List.<Attribute.TypeCompound>nil();
    4.24 +
    4.25 +    /*
    4.26       * The Symbol this Annotations instance belongs to
    4.27       */
    4.28      private final Symbol sym;
    4.29 @@ -97,6 +110,14 @@
    4.30          return type_attributes;
    4.31      }
    4.32  
    4.33 +    public List<Attribute.TypeCompound> getInitTypeAttributes() {
    4.34 +        return init_type_attributes;
    4.35 +    }
    4.36 +
    4.37 +    public List<Attribute.TypeCompound> getClassInitTypeAttributes() {
    4.38 +        return clinit_type_attributes;
    4.39 +    }
    4.40 +
    4.41      public void setDeclarationAttributes(List<Attribute.Compound> a) {
    4.42          Assert.check(pendingCompletion() || !isStarted());
    4.43          if (a == null) {
    4.44 @@ -112,12 +133,28 @@
    4.45          type_attributes = a;
    4.46      }
    4.47  
    4.48 +    public void setInitTypeAttributes(List<Attribute.TypeCompound> a) {
    4.49 +        if (a == null) {
    4.50 +            throw new NullPointerException();
    4.51 +        }
    4.52 +        init_type_attributes = a;
    4.53 +    }
    4.54 +
    4.55 +    public void setClassInitTypeAttributes(List<Attribute.TypeCompound> a) {
    4.56 +        if (a == null) {
    4.57 +            throw new NullPointerException();
    4.58 +        }
    4.59 +        clinit_type_attributes = a;
    4.60 +    }
    4.61 +
    4.62      public void setAttributes(Annotations other) {
    4.63          if (other == null) {
    4.64              throw new NullPointerException();
    4.65          }
    4.66          setDeclarationAttributes(other.getDeclarationAttributes());
    4.67          setTypeAttributes(other.getTypeAttributes());
    4.68 +        setInitTypeAttributes(other.getInitTypeAttributes());
    4.69 +        setClassInitTypeAttributes(other.getClassInitTypeAttributes());
    4.70      }
    4.71  
    4.72      public void setDeclarationAttributesWithCompletion(final Annotate.AnnotateRepeatedContext<Attribute.Compound> ctx) {
    4.73 @@ -232,6 +269,28 @@
    4.74          return this;
    4.75      }
    4.76  
    4.77 +    public Annotations appendInitTypeAttributes(List<Attribute.TypeCompound> l) {
    4.78 +        if (l.isEmpty()) {
    4.79 +            ; // no-op
    4.80 +        } else if (init_type_attributes.isEmpty()) {
    4.81 +            init_type_attributes = l;
    4.82 +        } else {
    4.83 +            init_type_attributes = init_type_attributes.appendList(l);
    4.84 +        }
    4.85 +        return this;
    4.86 +    }
    4.87 +
    4.88 +    public Annotations appendClassInitTypeAttributes(List<Attribute.TypeCompound> l) {
    4.89 +        if (l.isEmpty()) {
    4.90 +            ; // no-op
    4.91 +        } else if (clinit_type_attributes.isEmpty()) {
    4.92 +            clinit_type_attributes = l;
    4.93 +        } else {
    4.94 +            clinit_type_attributes = clinit_type_attributes.appendList(l);
    4.95 +        }
    4.96 +        return this;
    4.97 +    }
    4.98 +
    4.99      public Annotations prepend(List<Attribute.Compound> l) {
   4.100          attributes = filterDeclSentinels(attributes);
   4.101  

     5.1 --- a/src/share/classes/com/sun/tools/javac/code/Attribute.java	Tue May 14 13:55:35 2013 -0700
     5.2 +++ b/src/share/classes/com/sun/tools/javac/code/Attribute.java	Tue May 14 15:04:06 2013 -0700
     5.3 @@ -230,6 +230,42 @@
     5.4              this.position = position;
     5.5          }
     5.6  
     5.7 +        public boolean hasUnknownPosition() {
     5.8 +            return position == null || position.type == TargetType.UNKNOWN;
     5.9 +        }
    5.10 +
    5.11 +        public boolean isContainerTypeCompound() {
    5.12 +            if (isSynthesized() && values.size() == 1)
    5.13 +                return getFirstEmbeddedTC() != null;
    5.14 +            return false;
    5.15 +        }
    5.16 +
    5.17 +        private TypeCompound getFirstEmbeddedTC() {
    5.18 +            if (values.size() == 1) {
    5.19 +                Pair<MethodSymbol, Attribute> val = values.get(0);
    5.20 +                if (val.fst.getSimpleName().contentEquals("value")
    5.21 +                        && val.snd instanceof Array) {
    5.22 +                    Array arr = (Array) val.snd;
    5.23 +                    if (arr.values.length != 0
    5.24 +                            && arr.values[0] instanceof Attribute.TypeCompound)
    5.25 +                        return (Attribute.TypeCompound) arr.values[0];
    5.26 +                }
    5.27 +            }
    5.28 +            return null;
    5.29 +        }
    5.30 +
    5.31 +        public boolean tryFixPosition() {
    5.32 +            if (!isContainerTypeCompound())
    5.33 +                return false;
    5.34 +
    5.35 +            TypeCompound from = getFirstEmbeddedTC();
    5.36 +            if (from != null && from.position != null &&
    5.37 +                    from.position.type != TargetType.UNKNOWN) {
    5.38 +                position = from.position;
    5.39 +                return true;
    5.40 +            }
    5.41 +            return false;
    5.42 +        }
    5.43      }
    5.44  
    5.45      /** The value for an annotation element of an array type.

     6.1 --- a/src/share/classes/com/sun/tools/javac/code/Printer.java	Tue May 14 13:55:35 2013 -0700
     6.2 +++ b/src/share/classes/com/sun/tools/javac/code/Printer.java	Tue May 14 15:04:06 2013 -0700
     6.3 @@ -31,6 +31,7 @@
     6.4  
     6.5  import com.sun.tools.javac.api.Messages;
     6.6  import com.sun.tools.javac.code.Type.AnnotatedType;
     6.7 +import com.sun.tools.javac.code.Type.ArrayType;
     6.8  import com.sun.tools.javac.code.Symbol.*;
     6.9  import com.sun.tools.javac.code.Type.*;
    6.10  import com.sun.tools.javac.util.List;
    6.11 @@ -127,7 +128,7 @@
    6.12      }
    6.13  
    6.14      /**
    6.15 -     * Get a localized string represenation for a given type.
    6.16 +     * Get a localized string representation for a given type.
    6.17       *
    6.18       * @param t type to be displayed
    6.19       * @param locale the locale in which the string is to be rendered
    6.20 @@ -138,7 +139,7 @@
    6.21      }
    6.22  
    6.23      /**
    6.24 -     * Get a localized string represenation for a given symbol.
    6.25 +     * Get a localized string representation for a given symbol.
    6.26       *
    6.27       * @param s symbol to be displayed
    6.28       * @param locale the locale in which the string is to be rendered
    6.29 @@ -182,7 +183,33 @@
    6.30  
    6.31      @Override
    6.32      public String visitArrayType(ArrayType t, Locale locale) {
    6.33 -        return visit(t.elemtype, locale) + "[]";
    6.34 +        StringBuilder res = new StringBuilder();
    6.35 +        printBaseElementType(t, res, locale);
    6.36 +        printBrackets(t, res, locale);
    6.37 +        return res.toString();
    6.38 +    }
    6.39 +
    6.40 +    void printBaseElementType(Type t, StringBuilder sb, Locale locale) {
    6.41 +        Type arrel = t;
    6.42 +        while (arrel.getKind() == TypeKind.ARRAY) {
    6.43 +            arrel = arrel.unannotatedType();
    6.44 +            arrel = ((ArrayType) arrel).elemtype;
    6.45 +        }
    6.46 +        sb.append(visit(arrel, locale));
    6.47 +    }
    6.48 +
    6.49 +    void printBrackets(Type t, StringBuilder sb, Locale locale) {
    6.50 +        Type arrel = t;
    6.51 +        while (arrel.getKind() == TypeKind.ARRAY) {
    6.52 +            if (arrel.isAnnotated()) {
    6.53 +                sb.append(' ');
    6.54 +                sb.append(arrel.getAnnotationMirrors());
    6.55 +                sb.append(' ');
    6.56 +            }
    6.57 +            sb.append("[]");
    6.58 +            arrel = arrel.unannotatedType();
    6.59 +            arrel = ((ArrayType) arrel).elemtype;
    6.60 +        }
    6.61      }
    6.62  
    6.63      @Override
    6.64 @@ -237,10 +264,22 @@
    6.65      public String visitAnnotatedType(AnnotatedType t, Locale locale) {
    6.66          if (t.typeAnnotations != null &&
    6.67                  t.typeAnnotations.nonEmpty()) {
    6.68 -            // TODO: better logic for arrays, ...
    6.69 -            return "(" + t.typeAnnotations + " :: " + visit(t.underlyingType, locale) + ")";
    6.70 +            if (t.underlyingType.getKind() == TypeKind.ARRAY) {
    6.71 +                StringBuilder res = new StringBuilder();
    6.72 +                printBaseElementType(t, res, locale);
    6.73 +                printBrackets(t, res, locale);
    6.74 +                return res.toString();
    6.75 +            } else if (t.underlyingType.getKind() == TypeKind.DECLARED &&
    6.76 +                    t.underlyingType.getEnclosingType() != Type.noType) {
    6.77 +                return visit(t.underlyingType.getEnclosingType(), locale) +
    6.78 +                        ". " +
    6.79 +                        t.typeAnnotations +
    6.80 +                        " " + className((ClassType)t.underlyingType, false, locale);
    6.81 +            } else {
    6.82 +                return t.typeAnnotations + " " + visit(t.underlyingType, locale);
    6.83 +            }
    6.84          } else {
    6.85 -            return "({} :: " + visit(t.underlyingType, locale) + ")";
    6.86 +            return visit(t.underlyingType, locale);
    6.87          }
    6.88      }
    6.89  
    6.90 @@ -253,7 +292,7 @@
    6.91  
    6.92      /**
    6.93       * Converts a class name into a (possibly localized) string. Anonymous
    6.94 -     * inner classes gets converted into a localized string.
    6.95 +     * inner classes get converted into a localized string.
    6.96       *
    6.97       * @param t the type of the class whose name is to be rendered
    6.98       * @param longform if set, the class' fullname is displayed - if unset the
    6.99 @@ -266,7 +305,7 @@
   6.100          if (sym.name.length() == 0 && (sym.flags() & COMPOUND) != 0) {
   6.101              StringBuilder s = new StringBuilder(visit(t.supertype_field, locale));
   6.102              for (List<Type> is = t.interfaces_field; is.nonEmpty(); is = is.tail) {
   6.103 -                s.append("&");
   6.104 +                s.append('&');
   6.105                  s.append(visit(is.head, locale));
   6.106              }
   6.107              return s.toString();

     7.1 --- a/src/share/classes/com/sun/tools/javac/code/Type.java	Tue May 14 13:55:35 2013 -0700
     7.2 +++ b/src/share/classes/com/sun/tools/javac/code/Type.java	Tue May 14 15:04:06 2013 -0700
     7.3 @@ -25,8 +25,6 @@
     7.4  
     7.5  package com.sun.tools.javac.code;
     7.6  
     7.7 -import com.sun.tools.javac.model.JavacAnnoConstructs;
     7.8 -import com.sun.tools.javac.model.JavacTypes;
     7.9  import java.lang.annotation.Annotation;
    7.10  import java.util.Collections;
    7.11  import java.util.EnumMap;
    7.12 @@ -34,10 +32,10 @@
    7.13  import java.util.Map;
    7.14  import java.util.Set;
    7.15  
    7.16 -import javax.lang.model.element.AnnotationMirror;
    7.17  import javax.lang.model.type.*;
    7.18  
    7.19  import com.sun.tools.javac.code.Symbol.*;
    7.20 +import com.sun.tools.javac.model.JavacAnnoConstructs;
    7.21  import com.sun.tools.javac.util.*;
    7.22  import static com.sun.tools.javac.code.BoundKind.*;
    7.23  import static com.sun.tools.javac.code.Flags.*;
    7.24 @@ -729,7 +727,7 @@
    7.25                      return s.toString();
    7.26                  } else if (sym.name.isEmpty()) {
    7.27                      String s;
    7.28 -                    ClassType norm = (ClassType) tsym.type;
    7.29 +                    ClassType norm = (ClassType) tsym.type.unannotatedType();
    7.30                      if (norm == null) {
    7.31                          s = Log.getLocalizedString("anonymous.class", (Object)null);
    7.32                      } else if (norm.interfaces_field != null && norm.interfaces_field.nonEmpty()) {
    7.33 @@ -781,7 +779,7 @@
    7.34              return
    7.35                  getEnclosingType().isErroneous() ||
    7.36                  isErroneous(getTypeArguments()) ||
    7.37 -                this != tsym.type && tsym.type.isErroneous();
    7.38 +                this != tsym.type.unannotatedType() && tsym.type.isErroneous();
    7.39          }
    7.40  
    7.41          public boolean isParameterized() {
    7.42 @@ -1693,7 +1691,10 @@
    7.43  
    7.44          @Override
    7.45          public String toString() {
    7.46 -            // TODO more logic for arrays, etc.
    7.47 +            // This method is only used for internal debugging output.
    7.48 +            // See
    7.49 +            // com.sun.tools.javac.code.Printer.visitAnnotatedType(AnnotatedType, Locale)
    7.50 +            // for the user-visible logic.
    7.51              if (typeAnnotations != null &&
    7.52                      !typeAnnotations.isEmpty()) {
    7.53                  return "(" + typeAnnotations.toString() + " :: " + underlyingType.toString() + ")";
    7.54 @@ -1705,9 +1706,13 @@
    7.55          @Override
    7.56          public boolean contains(Type t)          { return underlyingType.contains(t); }
    7.57  
    7.58 -        // TODO: attach annotations?
    7.59          @Override
    7.60 -        public Type withTypeVar(Type t)          { return underlyingType.withTypeVar(t); }
    7.61 +        public Type withTypeVar(Type t) {
    7.62 +            // Don't create a new AnnotatedType, as 'this' will
    7.63 +            // get its annotations set later.
    7.64 +            underlyingType = underlyingType.withTypeVar(t);
    7.65 +            return this;
    7.66 +        }
    7.67  
    7.68          // TODO: attach annotations?
    7.69          @Override

     8.1 --- a/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Tue May 14 13:55:35 2013 -0700
     8.2 +++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Tue May 14 15:04:06 2013 -0700
     8.3 @@ -27,6 +27,7 @@
     8.4  
     8.5  import java.util.Iterator;
     8.6  
     8.7 +import com.sun.tools.javac.tree.JCTree.JCLambda;
     8.8  import com.sun.tools.javac.util.*;
     8.9  
    8.10  /** A type annotation position.
    8.11 @@ -145,9 +146,18 @@
    8.12      // For class extends, implements, and throws clauses
    8.13      public int type_index = Integer.MIN_VALUE;
    8.14  
    8.15 -    // For exception parameters, index into exception table
    8.16 +    // For exception parameters, index into exception table.
    8.17 +    // In com.sun.tools.javac.jvm.Gen.genCatch we first set the type_index
    8.18 +    // to the catch type index - that value is only temporary.
    8.19 +    // Then in com.sun.tools.javac.jvm.Code.fillExceptionParameterPositions
    8.20 +    // we use that value to determine the exception table index.
    8.21      public int exception_index = Integer.MIN_VALUE;
    8.22  
    8.23 +    // If this type annotation is within a lambda expression,
    8.24 +    // store a pointer to the lambda expression tree in order
    8.25 +    // to allow a later translation to the right method.
    8.26 +    public JCLambda onLambda = null;
    8.27 +
    8.28      public TypeAnnotationPosition() {}
    8.29  
    8.30      @Override
    8.31 @@ -258,6 +268,11 @@
    8.32          sb.append(", pos = ");
    8.33          sb.append(pos);
    8.34  
    8.35 +        if (onLambda != null) {
    8.36 +            sb.append(", onLambda hash = ");
    8.37 +            sb.append(onLambda.hashCode());
    8.38 +        }
    8.39 +
    8.40          sb.append(']');
    8.41          return sb.toString();
    8.42      }
    8.43 @@ -271,6 +286,17 @@
    8.44          return !type.isLocal() || isValidOffset;
    8.45      }
    8.46  
    8.47 +
    8.48 +    public boolean matchesPos(int pos) {
    8.49 +        return this.pos == pos;
    8.50 +    }
    8.51 +
    8.52 +    public void updatePosOffset(int to) {
    8.53 +        offset = to;
    8.54 +        lvarOffset = new int[]{to};
    8.55 +        isValidOffset = true;
    8.56 +    }
    8.57 +
    8.58      /**
    8.59       * Decode the binary representation for a type path and set
    8.60       * the {@code location} field.

     9.1 --- a/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Tue May 14 13:55:35 2013 -0700
     9.2 +++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotations.java	Tue May 14 15:04:06 2013 -0700
     9.3 @@ -49,12 +49,16 @@
     9.4  import com.sun.tools.javac.code.TypeAnnotationPosition.TypePathEntryKind;
     9.5  import com.sun.tools.javac.code.TypeTag;
     9.6  import com.sun.tools.javac.code.Symbol.VarSymbol;
     9.7 +import com.sun.tools.javac.code.Symbol.MethodSymbol;
     9.8 +import com.sun.tools.javac.comp.Annotate;
     9.9  import com.sun.tools.javac.comp.Annotate.Annotator;
    9.10  import com.sun.tools.javac.tree.JCTree;
    9.11  import com.sun.tools.javac.tree.JCTree.JCBlock;
    9.12  import com.sun.tools.javac.tree.JCTree.JCClassDecl;
    9.13  import com.sun.tools.javac.tree.JCTree.JCExpression;
    9.14 +import com.sun.tools.javac.tree.JCTree.JCLambda;
    9.15  import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
    9.16 +import com.sun.tools.javac.tree.JCTree.JCNewClass;
    9.17  import com.sun.tools.javac.tree.JCTree.JCTypeApply;
    9.18  import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
    9.19  import com.sun.tools.javac.tree.TreeScanner;
    9.20 @@ -81,17 +85,18 @@
    9.21       * determine the correct positions for type annotations.
    9.22       * This version only visits types in signatures and should be
    9.23       * called from MemberEnter.
    9.24 -     * The method returns the Annotator object that should be added
    9.25 -     * to the correct Annotate queue for later processing.
    9.26 +     * The method takes the Annotate object as parameter and
    9.27 +     * adds an Annotator to the correct Annotate queue for
    9.28 +     * later processing.
    9.29       */
    9.30 -    public static Annotator organizeTypeAnnotationsSignatures(final Symtab syms, final Names names,
    9.31 -            final Log log, final JCClassDecl tree) {
    9.32 -        return new Annotator() {
    9.33 +    public static void organizeTypeAnnotationsSignatures(final Symtab syms, final Names names,
    9.34 +            final Log log, final JCClassDecl tree, Annotate annotate) {
    9.35 +        annotate.afterRepeated( new Annotator() {
    9.36              @Override
    9.37              public void enterAnnotation() {
    9.38                  new TypeAnnotationPositions(syms, names, log, true).scan(tree);
    9.39              }
    9.40 -        };
    9.41 +        } );
    9.42      }
    9.43  
    9.44      /**
    9.45 @@ -102,10 +107,104 @@
    9.46          new TypeAnnotationPositions(syms, names, log, false).scan(tree);
    9.47      }
    9.48  
    9.49 +    public enum AnnotationType { DECLARATION, TYPE, BOTH };
    9.50 +
    9.51 +    /**
    9.52 +     * Determine whether an annotation is a declaration annotation,
    9.53 +     * a type annotation, or both.
    9.54 +     */
    9.55 +    public static AnnotationType annotationType(Symtab syms, Names names,
    9.56 +            Attribute.Compound a, Symbol s) {
    9.57 +        Attribute.Compound atTarget =
    9.58 +            a.type.tsym.attribute(syms.annotationTargetType.tsym);
    9.59 +        if (atTarget == null) {
    9.60 +            return inferTargetMetaInfo(a, s);
    9.61 +        }
    9.62 +        Attribute atValue = atTarget.member(names.value);
    9.63 +        if (!(atValue instanceof Attribute.Array)) {
    9.64 +            Assert.error("annotationType(): bad @Target argument " + atValue +
    9.65 +                    " (" + atValue.getClass() + ")");
    9.66 +            return AnnotationType.DECLARATION; // error recovery
    9.67 +        }
    9.68 +        Attribute.Array arr = (Attribute.Array) atValue;
    9.69 +        boolean isDecl = false, isType = false;
    9.70 +        for (Attribute app : arr.values) {
    9.71 +            if (!(app instanceof Attribute.Enum)) {
    9.72 +                Assert.error("annotationType(): unrecognized Attribute kind " + app +
    9.73 +                        " (" + app.getClass() + ")");
    9.74 +                isDecl = true;
    9.75 +                continue;
    9.76 +            }
    9.77 +            Attribute.Enum e = (Attribute.Enum) app;
    9.78 +            if (e.value.name == names.TYPE) {
    9.79 +                if (s.kind == Kinds.TYP)
    9.80 +                    isDecl = true;
    9.81 +            } else if (e.value.name == names.FIELD) {
    9.82 +                if (s.kind == Kinds.VAR &&
    9.83 +                        s.owner.kind != Kinds.MTH)
    9.84 +                    isDecl = true;
    9.85 +            } else if (e.value.name == names.METHOD) {
    9.86 +                if (s.kind == Kinds.MTH &&
    9.87 +                        !s.isConstructor())
    9.88 +                    isDecl = true;
    9.89 +            } else if (e.value.name == names.PARAMETER) {
    9.90 +                if (s.kind == Kinds.VAR &&
    9.91 +                        s.owner.kind == Kinds.MTH &&
    9.92 +                        (s.flags() & Flags.PARAMETER) != 0)
    9.93 +                    isDecl = true;
    9.94 +            } else if (e.value.name == names.CONSTRUCTOR) {
    9.95 +                if (s.kind == Kinds.MTH &&
    9.96 +                        s.isConstructor())
    9.97 +                    isDecl = true;
    9.98 +            } else if (e.value.name == names.LOCAL_VARIABLE) {
    9.99 +                if (s.kind == Kinds.VAR &&
   9.100 +                        s.owner.kind == Kinds.MTH &&
   9.101 +                        (s.flags() & Flags.PARAMETER) == 0)
   9.102 +                    isDecl = true;
   9.103 +            } else if (e.value.name == names.ANNOTATION_TYPE) {
   9.104 +                if (s.kind == Kinds.TYP &&
   9.105 +                        (s.flags() & Flags.ANNOTATION) != 0)
   9.106 +                    isDecl = true;
   9.107 +            } else if (e.value.name == names.PACKAGE) {
   9.108 +                if (s.kind == Kinds.PCK)
   9.109 +                    isDecl = true;
   9.110 +            } else if (e.value.name == names.TYPE_USE) {
   9.111 +                if (s.kind == Kinds.TYP ||
   9.112 +                        s.kind == Kinds.VAR ||
   9.113 +                        (s.kind == Kinds.MTH && !s.isConstructor() &&
   9.114 +                        !s.type.getReturnType().hasTag(TypeTag.VOID)) ||
   9.115 +                        (s.kind == Kinds.MTH && s.isConstructor()))
   9.116 +                    isType = true;
   9.117 +            } else if (e.value.name == names.TYPE_PARAMETER) {
   9.118 +                /* Irrelevant in this case */
   9.119 +                // TYPE_PARAMETER doesn't aid in distinguishing between
   9.120 +                // Type annotations and declaration annotations on an
   9.121 +                // Element
   9.122 +            } else {
   9.123 +                Assert.error("annotationType(): unrecognized Attribute name " + e.value.name +
   9.124 +                        " (" + e.value.name.getClass() + ")");
   9.125 +                isDecl = true;
   9.126 +            }
   9.127 +        }
   9.128 +        if (isDecl && isType) {
   9.129 +            return AnnotationType.BOTH;
   9.130 +        } else if (isType) {
   9.131 +            return AnnotationType.TYPE;
   9.132 +        } else {
   9.133 +            return AnnotationType.DECLARATION;
   9.134 +        }
   9.135 +    }
   9.136 +
   9.137 +    /** Infer the target annotation kind, if none is give.
   9.138 +     * We only infer declaration annotations.
   9.139 +     */
   9.140 +    private static AnnotationType inferTargetMetaInfo(Attribute.Compound a, Symbol s) {
   9.141 +        return AnnotationType.DECLARATION;
   9.142 +    }
   9.143 +
   9.144 +
   9.145      private static class TypeAnnotationPositions extends TreeScanner {
   9.146  
   9.147 -        private enum AnnotationType { DECLARATION, TYPE, BOTH };
   9.148 -
   9.149          private final Symtab syms;
   9.150          private final Names names;
   9.151          private final Log log;
   9.152 @@ -154,7 +253,7 @@
   9.153              ListBuffer<Attribute.TypeCompound> typeAnnos = new ListBuffer<Attribute.TypeCompound>();
   9.154  
   9.155              for (Attribute.Compound a : annotations) {
   9.156 -                switch (annotationType(a, sym)) {
   9.157 +                switch (annotationType(syms, names, a, sym)) {
   9.158                  case DECLARATION:
   9.159                      declAnnos.append(a);
   9.160                      break;
   9.161 @@ -175,6 +274,10 @@
   9.162              sym.annotations.reset();
   9.163              sym.annotations.setDeclarationAttributes(declAnnos.toList());
   9.164  
   9.165 +            if (typeAnnos.isEmpty()) {
   9.166 +                return;
   9.167 +            }
   9.168 +
   9.169              List<Attribute.TypeCompound> typeAnnotations = typeAnnos.toList();
   9.170  
   9.171              if (type == null) {
   9.172 @@ -190,16 +293,33 @@
   9.173  
   9.174              if (sym.getKind() == ElementKind.METHOD) {
   9.175                  sym.type.asMethodType().restype = type;
   9.176 +            } else if (sym.getKind() == ElementKind.PARAMETER) {
   9.177 +                sym.type = type;
   9.178 +                if (sym.getQualifiedName().equals(names._this)) {
   9.179 +                    sym.owner.type.asMethodType().recvtype = type;
   9.180 +                    // note that the typeAnnotations will also be added to the owner below.
   9.181 +                } else {
   9.182 +                    MethodType methType = sym.owner.type.asMethodType();
   9.183 +                    List<VarSymbol> params = ((MethodSymbol)sym.owner).params;
   9.184 +                    List<Type> oldArgs = methType.argtypes;
   9.185 +                    ListBuffer<Type> newArgs = new ListBuffer<Type>();
   9.186 +                    while (params.nonEmpty()) {
   9.187 +                        if (params.head == sym) {
   9.188 +                            newArgs.add(type);
   9.189 +                        } else {
   9.190 +                            newArgs.add(oldArgs.head);
   9.191 +                        }
   9.192 +                        oldArgs = oldArgs.tail;
   9.193 +                        params = params.tail;
   9.194 +                    }
   9.195 +                    methType.argtypes = newArgs.toList();
   9.196 +                }
   9.197              } else {
   9.198                  sym.type = type;
   9.199              }
   9.200  
   9.201              sym.annotations.appendUniqueTypes(typeAnnotations);
   9.202 -            if (sym.getKind() == ElementKind.PARAMETER &&
   9.203 -                    sym.getQualifiedName().equals(names._this)) {
   9.204 -                sym.owner.type.asMethodType().recvtype = type;
   9.205 -                // note that the typeAnnotations will also be added to the owner below.
   9.206 -            }
   9.207 +
   9.208              if (sym.getKind() == ElementKind.PARAMETER ||
   9.209                      sym.getKind() == ElementKind.LOCAL_VARIABLE ||
   9.210                      sym.getKind() == ElementKind.RESOURCE_VARIABLE ||
   9.211 @@ -276,10 +396,21 @@
   9.212                      TypeAnnotationPosition p = a.position;
   9.213                      p.location = p.location.prependList(depth.toList());
   9.214                  }
   9.215 +                typetree.type = toreturn;
   9.216                  return toreturn;
   9.217              } else if (type.hasTag(TypeTag.TYPEVAR)) {
   9.218                  // Nothing to do for type variables.
   9.219                  return type;
   9.220 +            } else if (type.getKind() == TypeKind.UNION) {
   9.221 +                // There is a TypeKind, but no TypeTag.
   9.222 +                JCTypeUnion tutree = (JCTypeUnion) typetree;
   9.223 +                JCExpression fst = tutree.alternatives.get(0);
   9.224 +                Type res = typeWithAnnotations(fst, fst.type, annotations, log);
   9.225 +                fst.type = res;
   9.226 +                // TODO: do we want to set res as first element in uct.alternatives?
   9.227 +                // UnionClassType uct = (com.sun.tools.javac.code.Type.UnionClassType)type;
   9.228 +                // Return the un-annotated union-type.
   9.229 +                return type;
   9.230              } else {
   9.231                  Type enclTy = type;
   9.232                  Element enclEl = type.asElement();
   9.233 @@ -357,6 +488,7 @@
   9.234                  }
   9.235  
   9.236                  Type ret = typeWithAnnotations(type, enclTy, annotations);
   9.237 +                typetree.type = ret;
   9.238                  return ret;
   9.239              }
   9.240          }
   9.241 @@ -480,94 +612,6 @@
   9.242              return new Attribute.TypeCompound(a, p);
   9.243          }
   9.244  
   9.245 -        private AnnotationType annotationType(Attribute.Compound a, Symbol s) {
   9.246 -            Attribute.Compound atTarget =
   9.247 -                a.type.tsym.attribute(syms.annotationTargetType.tsym);
   9.248 -            if (atTarget == null) {
   9.249 -                return inferTargetMetaInfo(a, s);
   9.250 -            }
   9.251 -            Attribute atValue = atTarget.member(names.value);
   9.252 -            if (!(atValue instanceof Attribute.Array)) {
   9.253 -                Assert.error("annotationType(): bad @Target argument " + atValue +
   9.254 -                        " (" + atValue.getClass() + ")");
   9.255 -                return AnnotationType.DECLARATION; // error recovery
   9.256 -            }
   9.257 -            Attribute.Array arr = (Attribute.Array) atValue;
   9.258 -            boolean isDecl = false, isType = false;
   9.259 -            for (Attribute app : arr.values) {
   9.260 -                if (!(app instanceof Attribute.Enum)) {
   9.261 -                    Assert.error("annotationType(): unrecognized Attribute kind " + app +
   9.262 -                            " (" + app.getClass() + ")");
   9.263 -                    isDecl = true;
   9.264 -                    continue;
   9.265 -                }
   9.266 -                Attribute.Enum e = (Attribute.Enum) app;
   9.267 -                if (e.value.name == names.TYPE) {
   9.268 -                    if (s.kind == Kinds.TYP)
   9.269 -                        isDecl = true;
   9.270 -                } else if (e.value.name == names.FIELD) {
   9.271 -                    if (s.kind == Kinds.VAR &&
   9.272 -                            s.owner.kind != Kinds.MTH)
   9.273 -                        isDecl = true;
   9.274 -                } else if (e.value.name == names.METHOD) {
   9.275 -                    if (s.kind == Kinds.MTH &&
   9.276 -                            !s.isConstructor())
   9.277 -                        isDecl = true;
   9.278 -                } else if (e.value.name == names.PARAMETER) {
   9.279 -                    if (s.kind == Kinds.VAR &&
   9.280 -                            s.owner.kind == Kinds.MTH &&
   9.281 -                            (s.flags() & Flags.PARAMETER) != 0)
   9.282 -                        isDecl = true;
   9.283 -                } else if (e.value.name == names.CONSTRUCTOR) {
   9.284 -                    if (s.kind == Kinds.MTH &&
   9.285 -                            s.isConstructor())
   9.286 -                        isDecl = true;
   9.287 -                } else if (e.value.name == names.LOCAL_VARIABLE) {
   9.288 -                    if (s.kind == Kinds.VAR &&
   9.289 -                            s.owner.kind == Kinds.MTH &&
   9.290 -                            (s.flags() & Flags.PARAMETER) == 0)
   9.291 -                        isDecl = true;
   9.292 -                } else if (e.value.name == names.ANNOTATION_TYPE) {
   9.293 -                    if (s.kind == Kinds.TYP &&
   9.294 -                            (s.flags() & Flags.ANNOTATION) != 0)
   9.295 -                        isDecl = true;
   9.296 -                } else if (e.value.name == names.PACKAGE) {
   9.297 -                    if (s.kind == Kinds.PCK)
   9.298 -                        isDecl = true;
   9.299 -                } else if (e.value.name == names.TYPE_USE) {
   9.300 -                    if (s.kind == Kinds.TYP ||
   9.301 -                            s.kind == Kinds.VAR ||
   9.302 -                            (s.kind == Kinds.MTH && !s.isConstructor() &&
   9.303 -                            !s.type.getReturnType().hasTag(TypeTag.VOID)) ||
   9.304 -                            (s.kind == Kinds.MTH && s.isConstructor()))
   9.305 -                        isType = true;
   9.306 -                } else if (e.value.name == names.TYPE_PARAMETER) {
   9.307 -                    /* Irrelevant in this case */
   9.308 -                    // TYPE_PARAMETER doesn't aid in distinguishing between
   9.309 -                    // Type annotations and declaration annotations on an
   9.310 -                    // Element
   9.311 -                } else {
   9.312 -                    Assert.error("annotationType(): unrecognized Attribute name " + e.value.name +
   9.313 -                            " (" + e.value.name.getClass() + ")");
   9.314 -                    isDecl = true;
   9.315 -                }
   9.316 -            }
   9.317 -            if (isDecl && isType) {
   9.318 -                return AnnotationType.BOTH;
   9.319 -            } else if (isType) {
   9.320 -                return AnnotationType.TYPE;
   9.321 -            } else {
   9.322 -                return AnnotationType.DECLARATION;
   9.323 -            }
   9.324 -        }
   9.325 -
   9.326 -        /** Infer the target annotation kind, if none is give.
   9.327 -         * We only infer declaration annotations.
   9.328 -         */
   9.329 -        private static AnnotationType inferTargetMetaInfo(Attribute.Compound a, Symbol s) {
   9.330 -            return AnnotationType.DECLARATION;
   9.331 -        }
   9.332 -
   9.333  
   9.334          /* This is the beginning of the second part of organizing
   9.335           * type annotations: determine the type annotation positions.
   9.336 @@ -585,7 +629,13 @@
   9.337  
   9.338              switch (frame.getKind()) {
   9.339                  case TYPE_CAST:
   9.340 +                    JCTypeCast frameTC = (JCTypeCast) frame;
   9.341                      p.type = TargetType.CAST;
   9.342 +                    if (frameTC.clazz.hasTag(Tag.TYPEINTERSECTION)) {
   9.343 +                        // This case was already handled by INTERSECTION_TYPE
   9.344 +                    } else {
   9.345 +                        p.type_index = 0;
   9.346 +                    }
   9.347                      p.pos = frame.pos;
   9.348                      return;
   9.349  
   9.350 @@ -595,8 +645,22 @@
   9.351                      return;
   9.352  
   9.353                  case NEW_CLASS:
   9.354 -                    JCNewClass frameNewClass = (JCNewClass)frame;
   9.355 -                    if (frameNewClass.typeargs.contains(tree)) {
   9.356 +                    JCNewClass frameNewClass = (JCNewClass) frame;
   9.357 +                    if (frameNewClass.def != null) {
   9.358 +                        // Special handling for anonymous class instantiations
   9.359 +                        JCClassDecl frameClassDecl = frameNewClass.def;
   9.360 +                        if (frameClassDecl.extending == tree) {
   9.361 +                            p.type = TargetType.CLASS_EXTENDS;
   9.362 +                            p.type_index = -1;
   9.363 +                        } else if (frameClassDecl.implementing.contains(tree)) {
   9.364 +                            p.type = TargetType.CLASS_EXTENDS;
   9.365 +                            p.type_index = frameClassDecl.implementing.indexOf(tree);
   9.366 +                        } else {
   9.367 +                            // In contrast to CLASS below, typarams cannot occur here.
   9.368 +                            Assert.error("Could not determine position of tree " + tree +
   9.369 +                                    " within frame " + frame);
   9.370 +                        }
   9.371 +                    } else if (frameNewClass.typeargs.contains(tree)) {
   9.372                          p.type = TargetType.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT;
   9.373                          p.type_index = frameNewClass.typeargs.indexOf(tree);
   9.374                      } else {
   9.375 @@ -649,6 +713,8 @@
   9.376                  }
   9.377  
   9.378                  case PARAMETERIZED_TYPE: {
   9.379 +                    List<JCTree> newPath = path.tail;
   9.380 +
   9.381                      if (((JCTypeApply)frame).clazz == tree) {
   9.382                          // generic: RAW; noop
   9.383                      } else if (((JCTypeApply)frame).arguments.contains(tree)) {
   9.384 @@ -656,13 +722,21 @@
   9.385                          int arg = taframe.arguments.indexOf(tree);
   9.386                          p.location = p.location.prepend(new TypePathEntry(TypePathEntryKind.TYPE_ARGUMENT, arg));
   9.387  
   9.388 -                        locateNestedTypes(taframe.type, p);
   9.389 +                        Type typeToUse;
   9.390 +                        if (newPath.tail != null && newPath.tail.head.hasTag(Tag.NEWCLASS)) {
   9.391 +                            // If we are within an anonymous class instantiation, use its type,
   9.392 +                            // because it contains a correctly nested type.
   9.393 +                            typeToUse = newPath.tail.head.type;
   9.394 +                        } else {
   9.395 +                            typeToUse = taframe.type;
   9.396 +                        }
   9.397 +
   9.398 +                        locateNestedTypes(typeToUse, p);
   9.399                      } else {
   9.400                          Assert.error("Could not determine type argument position of tree " + tree +
   9.401                                  " within frame " + frame);
   9.402                      }
   9.403  
   9.404 -                    List<JCTree> newPath = path.tail;
   9.405                      resolveFrame(newPath.head, newPath.tail.head, newPath, p);
   9.406                      return;
   9.407                  }
   9.408 @@ -780,6 +854,9 @@
   9.409                          default:
   9.410                              Assert.error("Found unexpected type annotation for variable: " + v + " with kind: " + v.getKind());
   9.411                      }
   9.412 +                    if (v.getKind() != ElementKind.FIELD) {
   9.413 +                        v.owner.annotations.appendUniqueTypes(v.getRawTypeAttributes());
   9.414 +                    }
   9.415                      return;
   9.416  
   9.417                  case ANNOTATED_TYPE: {
   9.418 @@ -789,6 +866,11 @@
   9.419                          // not care about inner types.
   9.420                          JCAnnotatedType atypetree = (JCAnnotatedType) frame;
   9.421                          final Type utype = atypetree.underlyingType.type;
   9.422 +                        if (utype == null) {
   9.423 +                            // This might happen during DeferredAttr;
   9.424 +                            // we will be back later.
   9.425 +                            return;
   9.426 +                        }
   9.427                          Symbol tsym = utype.tsym;
   9.428                          if (tsym.getKind().equals(ElementKind.TYPE_PARAMETER) ||
   9.429                                  utype.getKind().equals(TypeKind.WILDCARD) ||
   9.430 @@ -806,8 +888,6 @@
   9.431                  }
   9.432  
   9.433                  case UNION_TYPE: {
   9.434 -                    // TODO: can we store any information here to help in
   9.435 -                    // determining the final position?
   9.436                      List<JCTree> newPath = path.tail;
   9.437                      resolveFrame(newPath.head, newPath.tail.head, newPath, p);
   9.438                      return;
   9.439 @@ -873,11 +953,20 @@
   9.440  
   9.441          private static int methodParamIndex(List<JCTree> path, JCTree param) {
   9.442              List<JCTree> curr = path;
   9.443 -            while (curr.head.getTag() != Tag.METHODDEF) {
   9.444 +            while (curr.head.getTag() != Tag.METHODDEF &&
   9.445 +                    curr.head.getTag() != Tag.LAMBDA) {
   9.446                  curr = curr.tail;
   9.447              }
   9.448 -            JCMethodDecl method = (JCMethodDecl)curr.head;
   9.449 -            return method.params.indexOf(param);
   9.450 +            if (curr.head.getTag() == Tag.METHODDEF) {
   9.451 +                JCMethodDecl method = (JCMethodDecl)curr.head;
   9.452 +                return method.params.indexOf(param);
   9.453 +            } else if (curr.head.getTag() == Tag.LAMBDA) {
   9.454 +                JCLambda lambda = (JCLambda)curr.head;
   9.455 +                return lambda.params.indexOf(param);
   9.456 +            } else {
   9.457 +                Assert.error("methodParamIndex expected to find method or lambda for param: " + param);
   9.458 +                return -1;
   9.459 +            }
   9.460          }
   9.461  
   9.462          // Each class (including enclosed inner classes) is visited separately.
   9.463 @@ -889,6 +978,7 @@
   9.464              if (isInClass)
   9.465                  return;
   9.466              isInClass = true;
   9.467 +
   9.468              if (sigOnly) {
   9.469                  scan(tree.mods);
   9.470                  scan(tree.typarams);
   9.471 @@ -910,7 +1000,9 @@
   9.472                  return;
   9.473              }
   9.474              if (sigOnly) {
   9.475 -                {
   9.476 +                if (!tree.mods.annotations.isEmpty()) {
   9.477 +                    // Nothing to do for separateAnnotationsKinds if
   9.478 +                    // there are no annotations of either kind.
   9.479                      TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.480                      pos.type = TargetType.METHOD_RETURN;
   9.481                      if (tree.sym.isConstructor()) {
   9.482 @@ -923,7 +1015,10 @@
   9.483                                  tree.sym, pos);
   9.484                      }
   9.485                  }
   9.486 -                if (tree.recvparam != null && tree.recvparam.sym != null) {
   9.487 +                if (tree.recvparam != null && tree.recvparam.sym != null &&
   9.488 +                        !tree.recvparam.mods.annotations.isEmpty()) {
   9.489 +                    // Nothing to do for separateAnnotationsKinds if
   9.490 +                    // there are no annotations of either kind.
   9.491                      // TODO: make sure there are no declaration annotations.
   9.492                      TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.493                      pos.type = TargetType.METHOD_RECEIVER;
   9.494 @@ -933,11 +1028,15 @@
   9.495                  }
   9.496                  int i = 0;
   9.497                  for (JCVariableDecl param : tree.params) {
   9.498 -                    TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.499 -                    pos.type = TargetType.METHOD_FORMAL_PARAMETER;
   9.500 -                    pos.parameter_index = i;
   9.501 -                    pos.pos = param.vartype.pos;
   9.502 -                    separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
   9.503 +                    if (!param.mods.annotations.isEmpty()) {
   9.504 +                        // Nothing to do for separateAnnotationsKinds if
   9.505 +                        // there are no annotations of either kind.
   9.506 +                        TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.507 +                        pos.type = TargetType.METHOD_FORMAL_PARAMETER;
   9.508 +                        pos.parameter_index = i;
   9.509 +                        pos.pos = param.vartype.pos;
   9.510 +                        separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
   9.511 +                    }
   9.512                      ++i;
   9.513                  }
   9.514              }
   9.515 @@ -958,16 +1057,53 @@
   9.516              pop();
   9.517          }
   9.518  
   9.519 +        /* Store a reference to the current lambda expression, to
   9.520 +         * be used by all type annotations within this expression.
   9.521 +         */
   9.522 +        private JCLambda currentLambda = null;
   9.523 +
   9.524 +        public void visitLambda(JCLambda tree) {
   9.525 +            JCLambda prevLambda = currentLambda;
   9.526 +            try {
   9.527 +                currentLambda = tree;
   9.528 +
   9.529 +                int i = 0;
   9.530 +                for (JCVariableDecl param : tree.params) {
   9.531 +                    if (!param.mods.annotations.isEmpty()) {
   9.532 +                        // Nothing to do for separateAnnotationsKinds if
   9.533 +                        // there are no annotations of either kind.
   9.534 +                        TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.535 +                        pos.type = TargetType.METHOD_FORMAL_PARAMETER;
   9.536 +                        pos.parameter_index = i;
   9.537 +                        pos.pos = param.vartype.pos;
   9.538 +                        pos.onLambda = tree;
   9.539 +                        separateAnnotationsKinds(param.vartype, param.sym.type, param.sym, pos);
   9.540 +                    }
   9.541 +                    ++i;
   9.542 +                }
   9.543 +
   9.544 +                push(tree);
   9.545 +                scan(tree.body);
   9.546 +                scan(tree.params);
   9.547 +                pop();
   9.548 +            } finally {
   9.549 +                currentLambda = prevLambda;
   9.550 +            }
   9.551 +        }
   9.552 +
   9.553          /**
   9.554           * Resolve declaration vs. type annotations in variable declarations and
   9.555           * then determine the positions.
   9.556           */
   9.557          @Override
   9.558          public void visitVarDef(final JCVariableDecl tree) {
   9.559 -            if (tree.sym == null) {
   9.560 +            if (tree.mods.annotations.isEmpty()) {
   9.561 +                // Nothing to do for separateAnnotationsKinds if
   9.562 +                // there are no annotations of either kind.
   9.563 +            } else if (tree.sym == null) {
   9.564                  // Something is wrong already. Quietly ignore.
   9.565              } else if (tree.sym.getKind() == ElementKind.PARAMETER) {
   9.566 -                // Parameters are handled in visitMethodDef above.
   9.567 +                // Parameters are handled in visitMethodDef or visitLambda.
   9.568              } else if (tree.sym.getKind() == ElementKind.FIELD) {
   9.569                  if (sigOnly) {
   9.570                      TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.571 @@ -979,16 +1115,19 @@
   9.572                  TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.573                  pos.type = TargetType.LOCAL_VARIABLE;
   9.574                  pos.pos = tree.pos;
   9.575 +                pos.onLambda = currentLambda;
   9.576                  separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
   9.577              } else if (tree.sym.getKind() == ElementKind.EXCEPTION_PARAMETER) {
   9.578                  TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.579                  pos.type = TargetType.EXCEPTION_PARAMETER;
   9.580                  pos.pos = tree.pos;
   9.581 +                pos.onLambda = currentLambda;
   9.582                  separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
   9.583              } else if (tree.sym.getKind() == ElementKind.RESOURCE_VARIABLE) {
   9.584                  TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.585                  pos.type = TargetType.RESOURCE_VARIABLE;
   9.586                  pos.pos = tree.pos;
   9.587 +                pos.onLambda = currentLambda;
   9.588                  separateAnnotationsKinds(tree.vartype, tree.sym.type, tree.sym, pos);
   9.589              } else if (tree.sym.getKind() == ElementKind.ENUM_CONSTANT) {
   9.590                  // No type annotations can occur here.
   9.591 @@ -1031,6 +1170,40 @@
   9.592          }
   9.593  
   9.594          @Override
   9.595 +        public void visitNewClass(JCNewClass tree) {
   9.596 +            if (tree.def != null &&
   9.597 +                    !tree.def.mods.annotations.isEmpty()) {
   9.598 +                JCClassDecl classdecl = tree.def;
   9.599 +                TypeAnnotationPosition pos = new TypeAnnotationPosition();
   9.600 +                pos.type = TargetType.CLASS_EXTENDS;
   9.601 +                pos.pos = tree.pos;
   9.602 +                if (classdecl.extending == tree.clazz) {
   9.603 +                    pos.type_index = -1;
   9.604 +                } else if (classdecl.implementing.contains(tree.clazz)) {
   9.605 +                    pos.type_index = classdecl.implementing.indexOf(tree.clazz);
   9.606 +                } else {
   9.607 +                    // In contrast to CLASS elsewhere, typarams cannot occur here.
   9.608 +                    Assert.error("Could not determine position of tree " + tree);
   9.609 +                }
   9.610 +                Type before = classdecl.sym.type;
   9.611 +                separateAnnotationsKinds(classdecl, tree.clazz.type, classdecl.sym, pos);
   9.612 +
   9.613 +                // classdecl.sym.type now contains an annotated type, which
   9.614 +                // is not what we want there.
   9.615 +                // TODO: should we put this type somewhere in the superclass/interface?
   9.616 +                classdecl.sym.type = before;
   9.617 +            }
   9.618 +
   9.619 +            scan(tree.encl);
   9.620 +            scan(tree.typeargs);
   9.621 +            scan(tree.clazz);
   9.622 +            scan(tree.args);
   9.623 +
   9.624 +            // The class body will already be scanned.
   9.625 +            // scan(tree.def);
   9.626 +        }
   9.627 +
   9.628 +        @Override
   9.629          public void visitNewArray(JCNewArray tree) {
   9.630              findPosition(tree, tree, tree.annotations);
   9.631              int dimAnnosCount = tree.dimAnnotations.size();
   9.632 @@ -1040,6 +1213,7 @@
   9.633              for (int i = 0; i < dimAnnosCount; ++i) {
   9.634                  TypeAnnotationPosition p = new TypeAnnotationPosition();
   9.635                  p.pos = tree.pos;
   9.636 +                p.onLambda = currentLambda;
   9.637                  p.type = TargetType.NEW;
   9.638                  if (i != 0) {
   9.639                      depth = depth.append(TypePathEntry.ARRAY);
   9.640 @@ -1053,18 +1227,23 @@
   9.641              // int i = dimAnnosCount == 0 ? 0 : dimAnnosCount - 1;
   9.642              // TODO: is depth.size == i here?
   9.643              JCExpression elemType = tree.elemtype;
   9.644 +            depth = depth.append(TypePathEntry.ARRAY);
   9.645              while (elemType != null) {
   9.646                  if (elemType.hasTag(JCTree.Tag.ANNOTATED_TYPE)) {
   9.647                      JCAnnotatedType at = (JCAnnotatedType)elemType;
   9.648                      TypeAnnotationPosition p = new TypeAnnotationPosition();
   9.649                      p.type = TargetType.NEW;
   9.650                      p.pos = tree.pos;
   9.651 -                    p.location = p.location.appendList(depth.toList());
   9.652 +                    p.onLambda = currentLambda;
   9.653 +                    locateNestedTypes(elemType.type, p);
   9.654 +                    p.location = p.location.prependList(depth.toList());
   9.655                      setTypeAnnotationPos(at.annotations, p);
   9.656                      elemType = at.underlyingType;
   9.657                  } else if (elemType.hasTag(JCTree.Tag.TYPEARRAY)) {
   9.658                      depth = depth.append(TypePathEntry.ARRAY);
   9.659                      elemType = ((JCArrayTypeTree)elemType).elemtype;
   9.660 +                } else if (elemType.hasTag(JCTree.Tag.SELECT)) {
   9.661 +                    elemType = ((JCFieldAccess)elemType).selected;
   9.662                  } else {
   9.663                      break;
   9.664                  }
   9.665 @@ -1076,10 +1255,11 @@
   9.666              if (!annotations.isEmpty()) {
   9.667                  /*
   9.668                  System.out.println("Finding pos for: " + annotations);
   9.669 -                System.out.println("    tree: " + tree);
   9.670 -                System.out.println("    frame: " + frame);
   9.671 +                System.out.println("    tree: " + tree + " kind: " + tree.getKind());
   9.672 +                System.out.println("    frame: " + frame + " kind: " + frame.getKind());
   9.673                  */
   9.674                  TypeAnnotationPosition p = new TypeAnnotationPosition();
   9.675 +                p.onLambda = currentLambda;
   9.676                  resolveFrame(tree, frame, frames.toList(), p);
   9.677                  setTypeAnnotationPos(annotations, p);
   9.678              }
   9.679 @@ -1088,8 +1268,17 @@
   9.680          private static void setTypeAnnotationPos(List<JCAnnotation> annotations,
   9.681                  TypeAnnotationPosition position) {
   9.682              for (JCAnnotation anno : annotations) {
   9.683 -                ((Attribute.TypeCompound) anno.attribute).position = position;
   9.684 +                // attribute might be null during DeferredAttr;
   9.685 +                // we will be back later.
   9.686 +                if (anno.attribute != null) {
   9.687 +                    ((Attribute.TypeCompound) anno.attribute).position = position;
   9.688 +                }
   9.689              }
   9.690          }
   9.691 +
   9.692 +        @Override
   9.693 +        public String toString() {
   9.694 +            return super.toString() + ": sigOnly: " + sigOnly;
   9.695 +        }
   9.696      }
   9.697  }

    10.1 --- a/src/share/classes/com/sun/tools/javac/code/Types.java	Tue May 14 13:55:35 2013 -0700
    10.2 +++ b/src/share/classes/com/sun/tools/javac/code/Types.java	Tue May 14 15:04:06 2013 -0700
    10.3 @@ -26,7 +26,6 @@
    10.4  package com.sun.tools.javac.code;
    10.5  
    10.6  import java.lang.ref.SoftReference;
    10.7 -import java.util.Comparator;
    10.8  import java.util.HashSet;
    10.9  import java.util.HashMap;
   10.10  import java.util.Locale;
   10.11 @@ -34,8 +33,6 @@
   10.12  import java.util.Set;
   10.13  import java.util.WeakHashMap;
   10.14  
   10.15 -import javax.lang.model.type.TypeKind;
   10.16 -
   10.17  import com.sun.tools.javac.code.Attribute.RetentionPolicy;
   10.18  import com.sun.tools.javac.code.Lint.LintCategory;
   10.19  import com.sun.tools.javac.code.Type.UndetVar.InferenceBound;
   10.20 @@ -204,7 +201,7 @@
   10.21                      WildcardType unb = new WildcardType(syms.objectType,
   10.22                                                          BoundKind.UNBOUND,
   10.23                                                          syms.boundClass,
   10.24 -                                                        (TypeVar)parms.head);
   10.25 +                                                        (TypeVar)parms.head.unannotatedType());
   10.26                      if (!containsType(args.head, unb))
   10.27                          return false;
   10.28                      parms = parms.tail;
   10.29 @@ -268,7 +265,7 @@
   10.30                          List<Type> opens = openVars.toList();
   10.31                          ListBuffer<Type> qs = new ListBuffer<Type>();
   10.32                          for (List<Type> iter = opens; iter.nonEmpty(); iter = iter.tail) {
   10.33 -                            qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND, syms.boundClass, (TypeVar) iter.head));
   10.34 +                            qs.append(new WildcardType(syms.objectType, BoundKind.UNBOUND, syms.boundClass, (TypeVar) iter.head.unannotatedType()));
   10.35                          }
   10.36                          res = subst(res, opens, qs.toList());
   10.37                      }
   10.38 @@ -581,12 +578,12 @@
   10.39              //simply replace the wildcards with its bound
   10.40              for (Type t : formalInterface.getTypeArguments()) {
   10.41                  if (actualTypeargs.head.hasTag(WILDCARD)) {
   10.42 -                    WildcardType wt = (WildcardType)actualTypeargs.head;
   10.43 +                    WildcardType wt = (WildcardType)actualTypeargs.head.unannotatedType();
   10.44                      Type bound;
   10.45                      switch (wt.kind) {
   10.46                          case EXTENDS:
   10.47                          case UNBOUND:
   10.48 -                            CapturedType capVar = (CapturedType)capturedTypeargs.head;
   10.49 +                            CapturedType capVar = (CapturedType)capturedTypeargs.head.unannotatedType();
   10.50                              //use declared bound if it doesn't depend on formal type-args
   10.51                              bound = capVar.bound.containsAny(capturedSite.getTypeArguments()) ?
   10.52                                      wt.type : capVar.bound;
   10.53 @@ -964,6 +961,9 @@
   10.54                  isSameTypeStrict.visit(t, s) :
   10.55                  isSameTypeLoose.visit(t, s);
   10.56      }
   10.57 +    public boolean isSameAnnotatedType(Type t, Type s) {
   10.58 +        return isSameAnnotatedType.visit(t, s);
   10.59 +    }
   10.60      // where
   10.61          abstract class SameTypeVisitor extends TypeRelation {
   10.62  
   10.63 @@ -982,7 +982,7 @@
   10.64                      if (s.tag == TYPEVAR) {
   10.65                          //type-substitution does not preserve type-var types
   10.66                          //check that type var symbols and bounds are indeed the same
   10.67 -                        return sameTypeVars((TypeVar)t, (TypeVar)s);
   10.68 +                        return sameTypeVars((TypeVar)t.unannotatedType(), (TypeVar)s.unannotatedType());
   10.69                      }
   10.70                      else {
   10.71                          //special case for s == ? super X, where upper(s) = u
   10.72 @@ -1096,7 +1096,9 @@
   10.73           * Standard type-equality relation - type variables are considered
   10.74           * equals if they share the same type symbol.
   10.75           */
   10.76 -        TypeRelation isSameTypeLoose = new SameTypeVisitor() {
   10.77 +        TypeRelation isSameTypeLoose = new LooseSameTypeVisitor();
   10.78 +
   10.79 +        private class LooseSameTypeVisitor extends SameTypeVisitor {
   10.80              @Override
   10.81              boolean sameTypeVars(TypeVar tv1, TypeVar tv2) {
   10.82                  return tv1.tsym == tv2.tsym && visit(tv1.getUpperBound(), tv2.getUpperBound());
   10.83 @@ -1126,12 +1128,29 @@
   10.84                  if (!s.hasTag(WILDCARD)) {
   10.85                      return false;
   10.86                  } else {
   10.87 -                    WildcardType t2 = (WildcardType)s;
   10.88 +                    WildcardType t2 = (WildcardType)s.unannotatedType();
   10.89                      return t.kind == t2.kind &&
   10.90                              isSameType(t.type, t2.type, true);
   10.91                  }
   10.92              }
   10.93          };
   10.94 +
   10.95 +        /**
   10.96 +         * A version of LooseSameTypeVisitor that takes AnnotatedTypes
   10.97 +         * into account.
   10.98 +         */
   10.99 +        TypeRelation isSameAnnotatedType = new LooseSameTypeVisitor() {
  10.100 +            @Override
  10.101 +            public Boolean visitAnnotatedType(AnnotatedType t, Type s) {
  10.102 +                if (!s.isAnnotated())
  10.103 +                    return false;
  10.104 +                if (!t.getAnnotationMirrors().containsAll(s.getAnnotationMirrors()))
  10.105 +                    return false;
  10.106 +                if (!s.getAnnotationMirrors().containsAll(t.getAnnotationMirrors()))
  10.107 +                    return false;
  10.108 +                return visit(t.underlyingType, s);
  10.109 +            }
  10.110 +        };
  10.111      // </editor-fold>
  10.112  
  10.113      // <editor-fold defaultstate="collapsed" desc="Contains Type">
  10.114 @@ -1140,7 +1159,7 @@
  10.115          case UNDETVAR:
  10.116              if (s.tag == WILDCARD) {
  10.117                  UndetVar undetvar = (UndetVar)t;
  10.118 -                WildcardType wt = (WildcardType)s;
  10.119 +                WildcardType wt = (WildcardType)s.unannotatedType();
  10.120                  switch(wt.kind) {
  10.121                      case UNBOUND: //similar to ? extends Object
  10.122                      case EXTENDS: {
  10.123 @@ -1207,7 +1226,7 @@
  10.124  
  10.125              private Type U(Type t) {
  10.126                  while (t.tag == WILDCARD) {
  10.127 -                    WildcardType w = (WildcardType)t;
  10.128 +                    WildcardType w = (WildcardType)t.unannotatedType();
  10.129                      if (w.isSuperBound())
  10.130                          return w.bound == null ? syms.objectType : w.bound.bound;
  10.131                      else
  10.132 @@ -1218,7 +1237,7 @@
  10.133  
  10.134              private Type L(Type t) {
  10.135                  while (t.tag == WILDCARD) {
  10.136 -                    WildcardType w = (WildcardType)t;
  10.137 +                    WildcardType w = (WildcardType)t.unannotatedType();
  10.138                      if (w.isExtendsBound())
  10.139                          return syms.botType;
  10.140                      else
  10.141 @@ -1276,15 +1295,15 @@
  10.142          };
  10.143  
  10.144      public boolean isCaptureOf(Type s, WildcardType t) {
  10.145 -        if (s.tag != TYPEVAR || !((TypeVar)s).isCaptured())
  10.146 +        if (s.tag != TYPEVAR || !((TypeVar)s.unannotatedType()).isCaptured())
  10.147              return false;
  10.148 -        return isSameWildcard(t, ((CapturedType)s).wildcard);
  10.149 +        return isSameWildcard(t, ((CapturedType)s.unannotatedType()).wildcard);
  10.150      }
  10.151  
  10.152      public boolean isSameWildcard(WildcardType t, Type s) {
  10.153          if (s.tag != WILDCARD)
  10.154              return false;
  10.155 -        WildcardType w = (WildcardType)s;
  10.156 +        WildcardType w = (WildcardType)s.unannotatedType();
  10.157          return w.kind == t.kind && w.type == t.type;
  10.158      }
  10.159  
  10.160 @@ -1373,8 +1392,8 @@
  10.161  
  10.162                  if (t.isCompound() || s.isCompound()) {
  10.163                      return !t.isCompound() ?
  10.164 -                            visitIntersectionType((IntersectionClassType)s, t, true) :
  10.165 -                            visitIntersectionType((IntersectionClassType)t, s, false);
  10.166 +                            visitIntersectionType((IntersectionClassType)s.unannotatedType(), t, true) :
  10.167 +                            visitIntersectionType((IntersectionClassType)t.unannotatedType(), s, false);
  10.168                  }
  10.169  
  10.170                  if (s.tag == CLASS || s.tag == ARRAY) {
  10.171 @@ -3070,7 +3089,7 @@
  10.172              for (Type t : tvars) {
  10.173                  if (!first) s.append(", ");
  10.174                  first = false;
  10.175 -                appendTyparamString(((TypeVar)t), s);
  10.176 +                appendTyparamString(((TypeVar)t.unannotatedType()), s);
  10.177              }
  10.178              s.append('>');
  10.179              return s.toString();
  10.180 @@ -3710,9 +3729,9 @@
  10.181                 !currentS.isEmpty()) {
  10.182              if (currentS.head != currentT.head) {
  10.183                  captured = true;
  10.184 -                WildcardType Ti = (WildcardType)currentT.head;
  10.185 +                WildcardType Ti = (WildcardType)currentT.head.unannotatedType();
  10.186                  Type Ui = currentA.head.getUpperBound();
  10.187 -                CapturedType Si = (CapturedType)currentS.head;
  10.188 +                CapturedType Si = (CapturedType)currentS.head.unannotatedType();
  10.189                  if (Ui == null)
  10.190                      Ui = syms.objectType;
  10.191                  switch (Ti.kind) {
  10.192 @@ -3749,6 +3768,7 @@
  10.193              ListBuffer<Type> result = lb();
  10.194              for (Type t : types) {
  10.195                  if (t.tag == WILDCARD) {
  10.196 +                    t = t.unannotatedType();
  10.197                      Type bound = ((WildcardType)t).getExtendsBound();
  10.198                      if (bound == null)
  10.199                          bound = syms.objectType;
  10.200 @@ -3842,7 +3862,7 @@
  10.201  
  10.202      private boolean giveWarning(Type from, Type to) {
  10.203          List<Type> bounds = to.isCompound() ?
  10.204 -                ((IntersectionClassType)to).getComponents() : List.of(to);
  10.205 +                ((IntersectionClassType)to.unannotatedType()).getComponents() : List.of(to);
  10.206          for (Type b : bounds) {
  10.207              Type subFrom = asSub(from, b.tsym);
  10.208              if (b.isParameterized() &&
  10.209 @@ -4107,7 +4127,7 @@
  10.210  
  10.211          Type B(Type t) {
  10.212              while (t.tag == WILDCARD) {
  10.213 -                WildcardType w = (WildcardType)t;
  10.214 +                WildcardType w = (WildcardType)t.unannotatedType();
  10.215                  t = high ?
  10.216                      w.getExtendsBound() :
  10.217                      w.getSuperBound();
  10.218 @@ -4182,7 +4202,7 @@
  10.219  
  10.220          public boolean equals(Object obj) {
  10.221              return (obj instanceof UniqueType) &&
  10.222 -                types.isSameType(type, ((UniqueType)obj).type);
  10.223 +                types.isSameAnnotatedType(type, ((UniqueType)obj).type);
  10.224          }
  10.225  
  10.226          public String toString() {

    11.1 --- a/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Tue May 14 13:55:35 2013 -0700
    11.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Annotate.java	Tue May 14 15:04:06 2013 -0700
    11.3 @@ -216,18 +216,42 @@
    11.4      Attribute.Compound enterAnnotation(JCAnnotation a,
    11.5                                         Type expected,
    11.6                                         Env<AttrContext> env) {
    11.7 +        return enterAnnotation(a, expected, env, false);
    11.8 +    }
    11.9 +
   11.10 +    Attribute.TypeCompound enterTypeAnnotation(JCAnnotation a,
   11.11 +            Type expected,
   11.12 +            Env<AttrContext> env) {
   11.13 +        return (Attribute.TypeCompound) enterAnnotation(a, expected, env, true);
   11.14 +    }
   11.15 +
   11.16 +    // boolean typeAnnotation determines whether the method returns
   11.17 +    // a Compound (false) or TypeCompound (true).
   11.18 +    Attribute.Compound enterAnnotation(JCAnnotation a,
   11.19 +            Type expected,
   11.20 +            Env<AttrContext> env,
   11.21 +            boolean typeAnnotation) {
   11.22          // The annotation might have had its type attributed (but not checked)
   11.23          // by attr.attribAnnotationTypes during MemberEnter, in which case we do not
   11.24          // need to do it again.
   11.25          Type at = (a.annotationType.type != null ? a.annotationType.type
   11.26                    : attr.attribType(a.annotationType, env));
   11.27          a.type = chk.checkType(a.annotationType.pos(), at, expected);
   11.28 -        if (a.type.isErroneous())
   11.29 -            return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
   11.30 +        if (a.type.isErroneous()) {
   11.31 +            if (typeAnnotation) {
   11.32 +                return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(), null);
   11.33 +            } else {
   11.34 +                return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
   11.35 +            }
   11.36 +        }
   11.37          if ((a.type.tsym.flags() & Flags.ANNOTATION) == 0) {
   11.38              log.error(a.annotationType.pos(),
   11.39                        "not.annotation.type", a.type.toString());
   11.40 -            return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
   11.41 +            if (typeAnnotation) {
   11.42 +                return new Attribute.TypeCompound(a.type, List.<Pair<MethodSymbol,Attribute>>nil(), null);
   11.43 +            } else {
   11.44 +                return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());
   11.45 +            }
   11.46          }
   11.47          List<JCExpression> args = a.args;
   11.48          if (args.length() == 1 && !args.head.hasTag(ASSIGN)) {
   11.49 @@ -266,12 +290,21 @@
   11.50                             ((MethodSymbol)method, value));
   11.51              t.type = result;
   11.52          }
   11.53 -        // TODO: this should be a TypeCompound if "a" is a JCTypeAnnotation.
   11.54 -        // However, how do we find the correct position?
   11.55 -        Attribute.Compound ac = new Attribute.Compound(a.type, buf.toList());
   11.56 -        // TODO: is this something we want? Who would use it?
   11.57 -        // a.attribute = ac;
   11.58 -        return ac;
   11.59 +        if (typeAnnotation) {
   11.60 +            if (a.attribute == null || !(a.attribute instanceof Attribute.TypeCompound)) {
   11.61 +                // Create a new TypeCompound
   11.62 +                Attribute.TypeCompound tc = new Attribute.TypeCompound(a.type, buf.toList(), new TypeAnnotationPosition());
   11.63 +                a.attribute = tc;
   11.64 +                return tc;
   11.65 +            } else {
   11.66 +                // Use an existing TypeCompound
   11.67 +                return a.attribute;
   11.68 +            }
   11.69 +        } else {
   11.70 +            Attribute.Compound ac = new Attribute.Compound(a.type, buf.toList());
   11.71 +            a.attribute = ac;
   11.72 +            return ac;
   11.73 +        }
   11.74      }
   11.75  
   11.76      Attribute enterAttributeValue(Type expected,
   11.77 @@ -354,15 +387,6 @@
   11.78          return new Attribute.Error(attr.attribExpr(tree, env, expected));
   11.79      }
   11.80  
   11.81 -    Attribute.TypeCompound enterTypeAnnotation(JCAnnotation a,
   11.82 -            Type expected,
   11.83 -            Env<AttrContext> env) {
   11.84 -        Attribute.Compound c = enterAnnotation(a, expected, env);
   11.85 -        Attribute.TypeCompound tc = new Attribute.TypeCompound(c.type, c.values, new TypeAnnotationPosition());
   11.86 -        a.attribute = tc;
   11.87 -        return tc;
   11.88 -    }
   11.89 -
   11.90      /* *********************************
   11.91       * Support for repeating annotations
   11.92       ***********************************/

    12.1 --- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Tue May 14 13:55:35 2013 -0700
    12.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Tue May 14 15:04:06 2013 -0700
    12.3 @@ -768,7 +768,12 @@
    12.4          JavaFileObject prevSource = log.useSource(env.toplevel.sourcefile);
    12.5  
    12.6          try {
    12.7 -            memberEnter.typeAnnotate(initializer, env, env.info.enclVar);
    12.8 +            // Use null as symbol to not attach the type annotation to any symbol.
    12.9 +            // The initializer will later also be visited and then we'll attach
   12.10 +            // to the symbol.
   12.11 +            // This prevents having multiple type annotations, just because of
   12.12 +            // lazy constant value evaluation.
   12.13 +            memberEnter.typeAnnotate(initializer, env, null);
   12.14              annotate.flush();
   12.15              Type itype = attribExpr(initializer, env, type);
   12.16              if (itype.constValue() != null)
   12.17 @@ -935,11 +940,6 @@
   12.18                  Env<AttrContext> newEnv = memberEnter.methodEnv(tree, env);
   12.19                  attribType(tree.recvparam, newEnv);
   12.20                  chk.validate(tree.recvparam, newEnv);
   12.21 -                if (!(tree.recvparam.type == m.owner.type || types.isSameType(tree.recvparam.type, m.owner.type))) {
   12.22 -                    // The == covers the common non-generic case, but for generic classes we need isSameType;
   12.23 -                    // note that equals didn't work.
   12.24 -                    log.error(tree.recvparam.pos(), "incorrect.receiver.type");
   12.25 -                }
   12.26              }
   12.27  
   12.28              // annotation method checks
   12.29 @@ -1112,6 +1112,18 @@
   12.30              memberEnter.typeAnnotate(tree, localEnv, localEnv.info.scope.owner);
   12.31              annotate.flush();
   12.32  
   12.33 +            {
   12.34 +                // Store init and clinit type annotations with the ClassSymbol
   12.35 +                // to allow output in Gen.normalizeDefs.
   12.36 +                ClassSymbol cs = (ClassSymbol)env.info.scope.owner;
   12.37 +                List<Attribute.TypeCompound> tas = localEnv.info.scope.owner.getRawTypeAttributes();
   12.38 +                if ((tree.flags & STATIC) != 0) {
   12.39 +                    cs.annotations.appendClassInitTypeAttributes(tas);
   12.40 +                } else {
   12.41 +                    cs.annotations.appendInitTypeAttributes(tas);
   12.42 +                }
   12.43 +            }
   12.44 +
   12.45              attribStats(tree.stats, localEnv);
   12.46          } else {
   12.47              // Create a new local environment with a local scope.
   12.48 @@ -2131,6 +2143,11 @@
   12.49                      tree.constructor,
   12.50                      localEnv,
   12.51                      new ResultInfo(VAL, newMethodTemplate(syms.voidType, argtypes, typeargtypes)));
   12.52 +            } else {
   12.53 +                if (tree.clazz.hasTag(ANNOTATED_TYPE)) {
   12.54 +                    checkForDeclarationAnnotations(((JCAnnotatedType) tree.clazz).annotations,
   12.55 +                            tree.clazz.type.tsym);
   12.56 +                }
   12.57              }
   12.58  
   12.59              if (tree.constructor != null && tree.constructor.kind == MTH)
   12.60 @@ -2195,6 +2212,20 @@
   12.61                  }
   12.62              }
   12.63  
   12.64 +    private void checkForDeclarationAnnotations(List<? extends JCAnnotation> annotations,
   12.65 +            Symbol sym) {
   12.66 +        // Ensure that no declaration annotations are present.
   12.67 +        // Note that a tree type might be an AnnotatedType with
   12.68 +        // empty annotations, if only declaration annotations were given.
   12.69 +        // This method will raise an error for such a type.
   12.70 +        for (JCAnnotation ai : annotations) {
   12.71 +            if (TypeAnnotations.annotationType(syms, names, ai.attribute, sym) == TypeAnnotations.AnnotationType.DECLARATION) {
   12.72 +                log.error(ai.pos(), "annotation.type.not.applicable");
   12.73 +            }
   12.74 +        }
   12.75 +    }
   12.76 +
   12.77 +
   12.78      /** Make an attributed null check tree.
   12.79       */
   12.80      public JCExpression makeNullCheck(JCExpression arg) {
   12.81 @@ -2221,6 +2252,10 @@
   12.82                  attribExpr(l.head, localEnv, syms.intType);
   12.83                  owntype = new ArrayType(owntype, syms.arrayClass);
   12.84              }
   12.85 +            if (tree.elemtype.hasTag(ANNOTATED_TYPE)) {
   12.86 +                checkForDeclarationAnnotations(((JCAnnotatedType) tree.elemtype).annotations,
   12.87 +                        tree.elemtype.type.tsym);
   12.88 +            }
   12.89          } else {
   12.90              // we are seeing an untyped aggregate { ... }
   12.91              // this is allowed only if the prototype is an array
   12.92 @@ -3763,6 +3798,12 @@
   12.93                      }
   12.94                  }
   12.95                  owntype = new ClassType(clazzOuter, actuals, clazztype.tsym);
   12.96 +                if (clazztype.isAnnotated()) {
   12.97 +                    // Use the same AnnotatedType, because it will have
   12.98 +                    // its annotations set later.
   12.99 +                    ((AnnotatedType)clazztype).underlyingType = owntype;
  12.100 +                    owntype = clazztype;
  12.101 +                }
  12.102              } else {
  12.103                  if (formals.length() != 0) {
  12.104                      log.error(tree.pos(), "wrong.number.type.args",
  12.105 @@ -3961,7 +4002,14 @@
  12.106  
  12.107          ListBuffer<Attribute.TypeCompound> buf = ListBuffer.lb();
  12.108          for (JCAnnotation anno : annotations) {
  12.109 -            buf.append((Attribute.TypeCompound) anno.attribute);
  12.110 +            if (anno.attribute != null) {
  12.111 +                // TODO: this null-check is only needed for an obscure
  12.112 +                // ordering issue, where annotate.flush is called when
  12.113 +                // the attribute is not set yet. For an example failure
  12.114 +                // try the referenceinfos/NestedTypes.java test.
  12.115 +                // Any better solutions?
  12.116 +                buf.append((Attribute.TypeCompound) anno.attribute);
  12.117 +            }
  12.118          }
  12.119          return buf.toList();
  12.120      }
  12.121 @@ -4266,15 +4314,12 @@
  12.122          tree.accept(typeAnnotationsValidator);
  12.123      }
  12.124      //where
  12.125 -    private final JCTree.Visitor typeAnnotationsValidator =
  12.126 -        new TreeScanner() {
  12.127 +    private final JCTree.Visitor typeAnnotationsValidator = new TreeScanner() {
  12.128 +
  12.129 +        private boolean checkAllAnnotations = false;
  12.130 +
  12.131          public void visitAnnotation(JCAnnotation tree) {
  12.132 -            if (tree.hasTag(TYPE_ANNOTATION)) {
  12.133 -                // TODO: It seems to WMD as if the annotation in
  12.134 -                // parameters, in particular also the recvparam, are never
  12.135 -                // of type JCTypeAnnotation and therefore never checked!
  12.136 -                // Luckily this check doesn't really do anything that isn't
  12.137 -                // also done elsewhere.
  12.138 +            if (tree.hasTag(TYPE_ANNOTATION) || checkAllAnnotations) {
  12.139                  chk.validateTypeAnnotation(tree, false);
  12.140              }
  12.141              super.visitAnnotation(tree);
  12.142 @@ -4288,15 +4333,10 @@
  12.143              // super.visitTypeParameter(tree);
  12.144          }
  12.145          public void visitMethodDef(JCMethodDecl tree) {
  12.146 -            // Static methods cannot have receiver type annotations.
  12.147 -            // In test case FailOver15.java, the nested method getString has
  12.148 -            // a null sym, because an unknown class is instantiated.
  12.149 -            // I would say it's safe to skip.
  12.150 -            if (tree.sym != null && (tree.sym.flags() & Flags.STATIC) != 0) {
  12.151 -                if (tree.recvparam != null) {
  12.152 -                    // TODO: better error message. Is the pos good?
  12.153 -                    log.error(tree.recvparam.pos(), "annotation.type.not.applicable");
  12.154 -                }
  12.155 +            if (tree.recvparam != null &&
  12.156 +                    tree.recvparam.vartype.type.getKind() != TypeKind.ERROR) {
  12.157 +                checkForDeclarationAnnotations(tree.recvparam.mods.annotations,
  12.158 +                        tree.recvparam.vartype.type.tsym);
  12.159              }
  12.160              if (tree.restype != null && tree.restype.type != null) {
  12.161                  validateAnnotatedType(tree.restype, tree.restype.type);
  12.162 @@ -4318,9 +4358,30 @@
  12.163                  validateAnnotatedType(tree.clazz, tree.clazz.type);
  12.164              super.visitTypeTest(tree);
  12.165          }
  12.166 -        // TODO: what else do we need?
  12.167 -        // public void visitNewClass(JCNewClass tree) {
  12.168 -        // public void visitNewArray(JCNewArray tree) {
  12.169 +        public void visitNewClass(JCNewClass tree) {
  12.170 +            if (tree.clazz.hasTag(ANNOTATED_TYPE)) {
  12.171 +                boolean prevCheck = this.checkAllAnnotations;
  12.172 +                try {
  12.173 +                    this.checkAllAnnotations = true;
  12.174 +                    scan(((JCAnnotatedType)tree.clazz).annotations);
  12.175 +                } finally {
  12.176 +                    this.checkAllAnnotations = prevCheck;
  12.177 +                }
  12.178 +            }
  12.179 +            super.visitNewClass(tree);
  12.180 +        }
  12.181 +        public void visitNewArray(JCNewArray tree) {
  12.182 +            if (tree.elemtype != null && tree.elemtype.hasTag(ANNOTATED_TYPE)) {
  12.183 +                boolean prevCheck = this.checkAllAnnotations;
  12.184 +                try {
  12.185 +                    this.checkAllAnnotations = true;
  12.186 +                    scan(((JCAnnotatedType)tree.elemtype).annotations);
  12.187 +                } finally {
  12.188 +                    this.checkAllAnnotations = prevCheck;
  12.189 +                }
  12.190 +            }
  12.191 +            super.visitNewArray(tree);
  12.192 +        }
  12.193  
  12.194          /* I would want to model this after
  12.195           * com.sun.tools.javac.comp.Check.Validator.visitSelectInternal(JCFieldAccess)

    13.1 --- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Tue May 14 13:55:35 2013 -0700
    13.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Tue May 14 15:04:06 2013 -0700
    13.3 @@ -1213,7 +1213,7 @@
    13.4  
    13.5      /** Validate a type expression. That is,
    13.6       *  check that all type arguments of a parametric type are within
    13.7 -     *  their bounds. This must be done in a second phase after type attributon
    13.8 +     *  their bounds. This must be done in a second phase after type attribution
    13.9       *  since a class might have a subclass as type parameter bound. E.g:
   13.10       *
   13.11       *  <pre>{@code

    14.1 --- a/src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java	Tue May 14 13:55:35 2013 -0700
    14.2 +++ b/src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java	Tue May 14 15:04:06 2013 -0700
    14.3 @@ -25,12 +25,12 @@
    14.4  package com.sun.tools.javac.comp;
    14.5  
    14.6  import com.sun.tools.javac.tree.*;
    14.7 -import com.sun.tools.javac.tree.JCTree;
    14.8  import com.sun.tools.javac.tree.JCTree.*;
    14.9  import com.sun.tools.javac.tree.JCTree.JCMemberReference.ReferenceKind;
   14.10  import com.sun.tools.javac.tree.TreeMaker;
   14.11  import com.sun.tools.javac.tree.TreeScanner;
   14.12  import com.sun.tools.javac.tree.TreeTranslator;
   14.13 +import com.sun.tools.javac.code.Attribute;
   14.14  import com.sun.tools.javac.code.Kinds;
   14.15  import com.sun.tools.javac.code.Scope;
   14.16  import com.sun.tools.javac.code.Symbol;
   14.17 @@ -46,7 +46,6 @@
   14.18  import com.sun.tools.javac.comp.Lower.BasicFreeVarCollector;
   14.19  import com.sun.tools.javac.jvm.*;
   14.20  import com.sun.tools.javac.util.*;
   14.21 -import com.sun.tools.javac.util.List;
   14.22  import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
   14.23  import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
   14.24  
   14.25 @@ -238,6 +237,24 @@
   14.26          MethodSymbol sym = (MethodSymbol)localContext.translatedSym;
   14.27          MethodType lambdaType = (MethodType) sym.type;
   14.28  
   14.29 +        {
   14.30 +            MethodSymbol owner = (MethodSymbol) localContext.owner;
   14.31 +            ListBuffer<Attribute.TypeCompound> ownerTypeAnnos = new ListBuffer<Attribute.TypeCompound>();
   14.32 +            ListBuffer<Attribute.TypeCompound> lambdaTypeAnnos = new ListBuffer<Attribute.TypeCompound>();
   14.33 +
   14.34 +            for (Attribute.TypeCompound tc : owner.getRawTypeAttributes()) {
   14.35 +                if (tc.position.onLambda == tree) {
   14.36 +                    lambdaTypeAnnos.append(tc);
   14.37 +                } else {
   14.38 +                    ownerTypeAnnos.append(tc);
   14.39 +                }
   14.40 +            }
   14.41 +            if (lambdaTypeAnnos.nonEmpty()) {
   14.42 +                owner.annotations.setTypeAttributes(ownerTypeAnnos.toList());
   14.43 +                sym.annotations.setTypeAttributes(lambdaTypeAnnos.toList());
   14.44 +            }
   14.45 +        }
   14.46 +
   14.47          //create the method declaration hoisting the lambda body
   14.48          JCMethodDecl lambdaDecl = make.MethodDef(make.Modifiers(sym.flags_field),
   14.49                  sym.name,
   14.50 @@ -373,12 +390,15 @@
   14.51              if (lambdaContext.getSymbolMap(PARAM).containsKey(tree.sym)) {
   14.52                  Symbol translatedSym = lambdaContext.getSymbolMap(PARAM).get(tree.sym);
   14.53                  result = make.Ident(translatedSym).setType(tree.type);
   14.54 +                translatedSym.annotations.setTypeAttributes(tree.sym.getRawTypeAttributes());
   14.55              } else if (lambdaContext.getSymbolMap(LOCAL_VAR).containsKey(tree.sym)) {
   14.56                  Symbol translatedSym = lambdaContext.getSymbolMap(LOCAL_VAR).get(tree.sym);
   14.57                  result = make.Ident(translatedSym).setType(tree.type);
   14.58 +                translatedSym.annotations.setTypeAttributes(tree.sym.getRawTypeAttributes());
   14.59              } else if (lambdaContext.getSymbolMap(TYPE_VAR).containsKey(tree.sym)) {
   14.60                  Symbol translatedSym = lambdaContext.getSymbolMap(TYPE_VAR).get(tree.sym);
   14.61                  result = make.Ident(translatedSym).setType(translatedSym.type);
   14.62 +                translatedSym.annotations.setTypeAttributes(tree.sym.getRawTypeAttributes());
   14.63              } else if (lambdaContext.getSymbolMap(CAPTURED_VAR).containsKey(tree.sym)) {
   14.64                  Symbol translatedSym = lambdaContext.getSymbolMap(CAPTURED_VAR).get(tree.sym);
   14.65                  result = make.Ident(translatedSym).setType(tree.type);
   14.66 @@ -1676,24 +1696,33 @@
   14.67               * synthetic lambda body
   14.68               */
   14.69              Symbol translate(Name name, final Symbol sym, LambdaSymbolKind skind) {
   14.70 +                Symbol ret;
   14.71                  switch (skind) {
   14.72                      case CAPTURED_THIS:
   14.73 -                        return sym;  // self represented
   14.74 +                        ret = sym;  // self represented
   14.75 +                        break;
   14.76                      case TYPE_VAR:
   14.77                          // Just erase the type var
   14.78 -                        return new VarSymbol(sym.flags(), name,
   14.79 +                        ret = new VarSymbol(sym.flags(), name,
   14.80                                  types.erasure(sym.type), sym.owner);
   14.81 +                        break;
   14.82                      case CAPTURED_VAR:
   14.83 -                        return new VarSymbol(SYNTHETIC | FINAL, name, types.erasure(sym.type), translatedSym) {
   14.84 +                        ret = new VarSymbol(SYNTHETIC | FINAL, name, types.erasure(sym.type), translatedSym) {
   14.85                              @Override
   14.86                              public Symbol baseSymbol() {
   14.87                                  //keep mapping with original captured symbol
   14.88                                  return sym;
   14.89                              }
   14.90                          };
   14.91 +                        break;
   14.92                      default:
   14.93 -                        return makeSyntheticVar(FINAL, name, types.erasure(sym.type), translatedSym);
   14.94 +                        ret = makeSyntheticVar(FINAL, name, types.erasure(sym.type), translatedSym);
   14.95                  }
   14.96 +                if (ret != sym) {
   14.97 +                    ret.annotations.setDeclarationAttributes(sym.getRawAttributes());
   14.98 +                    ret.annotations.setTypeAttributes(sym.getRawTypeAttributes());
   14.99 +                }
  14.100 +                return ret;
  14.101              }
  14.102  
  14.103              void addSymbol(Symbol sym, LambdaSymbolKind skind) {

    15.1 --- a/src/share/classes/com/sun/tools/javac/comp/Lower.java	Tue May 14 13:55:35 2013 -0700
    15.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java	Tue May 14 15:04:06 2013 -0700
    15.3 @@ -28,6 +28,7 @@
    15.4  import java.util.*;
    15.5  
    15.6  import com.sun.tools.javac.code.*;
    15.7 +import com.sun.tools.javac.code.Type.AnnotatedType;
    15.8  import com.sun.tools.javac.jvm.*;
    15.9  import com.sun.tools.javac.main.Option.PkgInfo;
   15.10  import com.sun.tools.javac.tree.*;
   15.11 @@ -2767,10 +2768,28 @@
   15.12          }
   15.13  
   15.14      public void visitAnnotatedType(JCAnnotatedType tree) {
   15.15 -        // No need to retain type annotations any longer.
   15.16 +        // No need to retain type annotations in the tree
   15.17          // tree.annotations = translate(tree.annotations);
   15.18 +        tree.annotations = List.nil();
   15.19          tree.underlyingType = translate(tree.underlyingType);
   15.20 -        result = tree.underlyingType;
   15.21 +        // but maintain type annotations in the type.
   15.22 +        if (tree.type.isAnnotated()) {
   15.23 +            if (tree.underlyingType.type.isAnnotated()) {
   15.24 +                // The erasure of a type variable might be annotated.
   15.25 +                // Merge all annotations.
   15.26 +                AnnotatedType newat = (AnnotatedType) tree.underlyingType.type;
   15.27 +                AnnotatedType at = (AnnotatedType) tree.type;
   15.28 +                at.underlyingType = newat.underlyingType;
   15.29 +                newat.typeAnnotations = at.typeAnnotations.appendList(newat.typeAnnotations);
   15.30 +                tree.type = newat;
   15.31 +            } else {
   15.32 +                // Create a new AnnotatedType to have the correct tag.
   15.33 +                AnnotatedType oldat = (AnnotatedType) tree.type;
   15.34 +                tree.type = new AnnotatedType(tree.underlyingType.type);
   15.35 +                ((AnnotatedType) tree.type).typeAnnotations = oldat.typeAnnotations;
   15.36 +            }
   15.37 +        }
   15.38 +        result = tree;
   15.39      }
   15.40  
   15.41      public void visitTypeCast(JCTypeCast tree) {

    16.1 --- a/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Tue May 14 13:55:35 2013 -0700
    16.2 +++ b/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Tue May 14 15:04:06 2013 -0700
    16.3 @@ -31,7 +31,6 @@
    16.4  import java.util.Map;
    16.5  import java.util.Set;
    16.6  
    16.7 -import javax.lang.model.type.TypeKind;
    16.8  import javax.tools.JavaFileObject;
    16.9  
   16.10  import com.sun.tools.javac.code.*;
   16.11 @@ -617,7 +616,26 @@
   16.12              if (TreeInfo.isEnumInit(tree)) {
   16.13                  attr.attribIdentAsEnumType(localEnv, (JCIdent)tree.vartype);
   16.14              } else {
   16.15 +                // Make sure type annotations are processed.
   16.16 +                // But we don't have a symbol to attach them to yet - use null.
   16.17 +                typeAnnotate(tree.vartype, env, null);
   16.18                  attr.attribType(tree.vartype, localEnv);
   16.19 +                if (tree.nameexpr != null) {
   16.20 +                    attr.attribExpr(tree.nameexpr, localEnv);
   16.21 +                    MethodSymbol m = localEnv.enclMethod.sym;
   16.22 +                    if (m.isConstructor()) {
   16.23 +                        Type outertype = m.owner.owner.type;
   16.24 +                        if (outertype.hasTag(TypeTag.CLASS)) {
   16.25 +                            checkType(tree.vartype, outertype, "incorrect.constructor.receiver.type");
   16.26 +                            checkType(tree.nameexpr, outertype, "incorrect.constructor.receiver.name");
   16.27 +                        } else {
   16.28 +                            log.error(tree, "receiver.parameter.not.applicable.constructor.toplevel.class");
   16.29 +                        }
   16.30 +                    } else {
   16.31 +                        checkType(tree.vartype, m.owner.type, "incorrect.receiver.type");
   16.32 +                        checkType(tree.nameexpr, m.owner.type, "incorrect.receiver.name");
   16.33 +                    }
   16.34 +                }
   16.35              }
   16.36          } finally {
   16.37              chk.setDeferredLintHandler(prevLintHandler);
   16.38 @@ -651,10 +669,16 @@
   16.39              enclScope.enter(v);
   16.40          }
   16.41          annotateLater(tree.mods.annotations, localEnv, v);
   16.42 -        typeAnnotate(tree.vartype, env, tree.sym);
   16.43 +        typeAnnotate(tree.vartype, env, v);
   16.44          annotate.flush();
   16.45          v.pos = tree.pos;
   16.46      }
   16.47 +    // where
   16.48 +    void checkType(JCTree tree, Type type, String diag) {
   16.49 +        if (!tree.type.isErroneous() && !types.isSameType(tree.type, type)) {
   16.50 +            log.error(tree, diag, type, tree.type);
   16.51 +        }
   16.52 +    }
   16.53  
   16.54      /** Create a fresh environment for a variable's initializer.
   16.55       *  If the variable is a field, the owner of the environment's scope
   16.56 @@ -1040,9 +1064,12 @@
   16.57                  isFirst = true;
   16.58              }
   16.59          }
   16.60 -        annotate.afterRepeated(TypeAnnotations.organizeTypeAnnotationsSignatures(syms, names, log, tree));
   16.61 +        TypeAnnotations.organizeTypeAnnotationsSignatures(syms, names, log, tree, annotate);
   16.62      }
   16.63  
   16.64 +    /*
   16.65 +     * If the symbol is non-null, attach the type annotation to it.
   16.66 +     */
   16.67      private void actualEnterTypeAnnotations(final List<JCAnnotation> annotations,
   16.68              final Env<AttrContext> env,
   16.69              final Symbol s) {
   16.70 @@ -1075,8 +1102,10 @@
   16.71              }
   16.72          }
   16.73  
   16.74 -        s.annotations.appendTypeAttributesWithCompletion(
   16.75 -                annotate.new AnnotateRepeatedContext<Attribute.TypeCompound>(env, annotated, pos, log, true));
   16.76 +        if (s != null) {
   16.77 +            s.annotations.appendTypeAttributesWithCompletion(
   16.78 +                    annotate.new AnnotateRepeatedContext<Attribute.TypeCompound>(env, annotated, pos, log, true));
   16.79 +        }
   16.80      }
   16.81  
   16.82      public void typeAnnotate(final JCTree tree, final Env<AttrContext> env, final Symbol sym) {
   16.83 @@ -1150,6 +1179,33 @@
   16.84              // Do not annotate the body, just the signature.
   16.85              // scan(tree.body);
   16.86          }
   16.87 +
   16.88 +        @Override
   16.89 +        public void visitVarDef(final JCVariableDecl tree) {
   16.90 +            if (sym != null && sym.kind == Kinds.VAR) {
   16.91 +                // Don't visit a parameter once when the sym is the method
   16.92 +                // and once when the sym is the parameter.
   16.93 +                scan(tree.mods);
   16.94 +                scan(tree.vartype);
   16.95 +            }
   16.96 +            scan(tree.init);
   16.97 +        }
   16.98 +
   16.99 +        @Override
  16.100 +        public void visitClassDef(JCClassDecl tree) {
  16.101 +            // We can only hit a classdef if it is declared within
  16.102 +            // a method. Ignore it - the class will be visited
  16.103 +            // separately later.
  16.104 +        }
  16.105 +
  16.106 +        @Override
  16.107 +        public void visitNewClass(JCNewClass tree) {
  16.108 +            if (tree.def == null) {
  16.109 +                // For an anonymous class instantiation the class
  16.110 +                // will be visited separately.
  16.111 +                super.visitNewClass(tree);
  16.112 +            }
  16.113 +        }
  16.114      }
  16.115  
  16.116  

    17.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Tue May 14 13:55:35 2013 -0700
    17.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Tue May 14 15:04:06 2013 -0700
    17.3 @@ -1518,7 +1518,7 @@
    17.4              break;
    17.5          // exception parameter
    17.6          case EXCEPTION_PARAMETER:
    17.7 -            position.exception_index = nextByte();
    17.8 +            position.exception_index = nextChar();
    17.9              break;
   17.10          // method receiver
   17.11          case METHOD_RECEIVER:

    18.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Tue May 14 13:55:35 2013 -0700
    18.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Tue May 14 15:04:06 2013 -0700
    18.3 @@ -632,7 +632,7 @@
    18.4              acount++;
    18.5          }
    18.6          acount += writeJavaAnnotations(sym.getRawAttributes());
    18.7 -        acount += writeTypeAnnotations(sym.getRawTypeAttributes());
    18.8 +        acount += writeTypeAnnotations(sym.getRawTypeAttributes(), false);
    18.9          return acount;
   18.10      }
   18.11  
   18.12 @@ -759,44 +759,30 @@
   18.13          return attrCount;
   18.14      }
   18.15  
   18.16 -    int writeTypeAnnotations(List<Attribute.TypeCompound> typeAnnos) {
   18.17 +    int writeTypeAnnotations(List<Attribute.TypeCompound> typeAnnos, boolean inCode) {
   18.18          if (typeAnnos.isEmpty()) return 0;
   18.19  
   18.20          ListBuffer<Attribute.TypeCompound> visibles = ListBuffer.lb();
   18.21          ListBuffer<Attribute.TypeCompound> invisibles = ListBuffer.lb();
   18.22  
   18.23          for (Attribute.TypeCompound tc : typeAnnos) {
   18.24 -            if (tc.position == null || tc.position.type == TargetType.UNKNOWN) {
   18.25 -                boolean found = false;
   18.26 -                // TODO: the position for the container annotation of a
   18.27 -                // repeating type annotation has to be set.
   18.28 -                // This cannot be done when the container is created, because
   18.29 -                // then the position is not determined yet.
   18.30 -                // How can we link these pieces better together?
   18.31 -                if (tc.values.size() == 1) {
   18.32 -                    Pair<MethodSymbol, Attribute> val = tc.values.get(0);
   18.33 -                    if (val.fst.getSimpleName().contentEquals("value") &&
   18.34 -                            val.snd instanceof Attribute.Array) {
   18.35 -                        Attribute.Array arr = (Attribute.Array) val.snd;
   18.36 -                        if (arr.values.length != 0 &&
   18.37 -                                arr.values[0] instanceof Attribute.TypeCompound) {
   18.38 -                            TypeCompound atycomp = (Attribute.TypeCompound) arr.values[0];
   18.39 -                            if (atycomp.position.type != TargetType.UNKNOWN) {
   18.40 -                                tc.position = atycomp.position;
   18.41 -                                found = true;
   18.42 -                            }
   18.43 -                        }
   18.44 -                    }
   18.45 -                }
   18.46 -                if (!found) {
   18.47 +            if (tc.hasUnknownPosition()) {
   18.48 +                boolean fixed = tc.tryFixPosition();
   18.49 +
   18.50 +                // Could we fix it?
   18.51 +                if (!fixed) {
   18.52                      // This happens for nested types like @A Outer. @B Inner.
   18.53                      // For method parameters we get the annotation twice! Once with
   18.54                      // a valid position, once unknown.
   18.55                      // TODO: find a cleaner solution.
   18.56 -                    // System.err.println("ClassWriter: Position UNKNOWN in type annotation: " + tc);
   18.57 +                    PrintWriter pw = log.getWriter(Log.WriterKind.ERROR);
   18.58 +                    pw.println("ClassWriter: Position UNKNOWN in type annotation: " + tc);
   18.59                      continue;
   18.60                  }
   18.61              }
   18.62 +
   18.63 +            if (tc.position.type.isLocal() != inCode)
   18.64 +                continue;
   18.65              if (!tc.position.emitToClassfile())
   18.66                  continue;
   18.67              switch (types.getRetention(tc)) {
   18.68 @@ -936,7 +922,7 @@
   18.69              break;
   18.70          // exception parameter
   18.71          case EXCEPTION_PARAMETER:
   18.72 -            databuf.appendByte(p.exception_index);
   18.73 +            databuf.appendChar(p.exception_index);
   18.74              break;
   18.75          // method receiver
   18.76          case METHOD_RECEIVER:
   18.77 @@ -1241,6 +1227,9 @@
   18.78              endAttr(alenIdx);
   18.79              acount++;
   18.80          }
   18.81 +
   18.82 +        acount += writeTypeAnnotations(code.meth.getRawTypeAttributes(), true);
   18.83 +
   18.84          endAttrs(acountIdx, acount);
   18.85      }
   18.86      //where
   18.87 @@ -1627,7 +1616,7 @@
   18.88              out = null;
   18.89          } finally {
   18.90              if (out != null) {
   18.91 -                // if we are propogating an exception, delete the file
   18.92 +                // if we are propagating an exception, delete the file
   18.93                  out.close();
   18.94                  outFile.delete();
   18.95                  outFile = null;
   18.96 @@ -1741,7 +1730,7 @@
   18.97  
   18.98          acount += writeFlagAttrs(c.flags());
   18.99          acount += writeJavaAnnotations(c.getRawAttributes());
  18.100 -        acount += writeTypeAnnotations(c.getRawTypeAttributes());
  18.101 +        acount += writeTypeAnnotations(c.getRawTypeAttributes(), false);
  18.102          acount += writeEnclosingMethodAttribute(c);
  18.103          acount += writeExtraClassAttributes(c);
  18.104  

    19.1 --- a/src/share/classes/com/sun/tools/javac/jvm/Code.java	Tue May 14 13:55:35 2013 -0700
    19.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/Code.java	Tue May 14 15:04:06 2013 -0700
    19.3 @@ -1010,7 +1010,16 @@
    19.4              state.pop(((Symbol)(pool.pool[od])).erasure(types));
    19.5              break;
    19.6          case new_:
    19.7 -            state.push(uninitializedObject(((Symbol)(pool.pool[od])).erasure(types), cp-3));
    19.8 +            Symbol sym;
    19.9 +            if (pool.pool[od] instanceof UniqueType) {
   19.10 +                // Required by change in Gen.makeRef to allow
   19.11 +                // annotated types.
   19.12 +                // TODO: is this needed anywhere else?
   19.13 +                sym = ((UniqueType)(pool.pool[od])).type.tsym;
   19.14 +            } else {
   19.15 +                sym = (Symbol)(pool.pool[od]);
   19.16 +            }
   19.17 +            state.push(uninitializedObject(sym.erasure(types), cp-3));
   19.18              break;
   19.19          case sipush:
   19.20              state.push(syms.intType);
   19.21 @@ -1972,25 +1981,38 @@
   19.22              if (lv == null || lv.sym == null
   19.23                      || lv.sym.annotations.isTypesEmpty()
   19.24                      || !lv.sym.isExceptionParameter())
   19.25 -                return;
   19.26 -
   19.27 -            int exidx = findExceptionIndex(lv);
   19.28 +                continue;
   19.29  
   19.30              for (Attribute.TypeCompound ta : lv.sym.getRawTypeAttributes()) {
   19.31                  TypeAnnotationPosition p = ta.position;
   19.32 -                p.exception_index = exidx;
   19.33 +                // At this point p.type_index contains the catch type index.
   19.34 +                // Use that index to determine the exception table index.
   19.35 +                // We can afterwards discard the type_index.
   19.36 +                // A TA position is shared for all type annotations in the
   19.37 +                // same location; updating one is enough.
   19.38 +                // Use -666 as a marker that the exception_index was already updated.
   19.39 +                if (p.type_index != -666) {
   19.40 +                    p.exception_index = findExceptionIndex(p.type_index);
   19.41 +                    p.type_index = -666;
   19.42 +                }
   19.43              }
   19.44          }
   19.45      }
   19.46  
   19.47 -    private int findExceptionIndex(LocalVar lv) {
   19.48 +    private int findExceptionIndex(int catchType) {
   19.49 +        if (catchType == Integer.MIN_VALUE) {
   19.50 +            // We didn't set the catch type index correctly.
   19.51 +            // This shouldn't happen.
   19.52 +            // TODO: issue error?
   19.53 +            return -1;
   19.54 +        }
   19.55          List<char[]> iter = catchInfo.toList();
   19.56          int len = catchInfo.length();
   19.57          for (int i = 0; i < len; ++i) {
   19.58              char[] catchEntry = iter.head;
   19.59              iter = iter.tail;
   19.60 -            char handlerpc = catchEntry[2];
   19.61 -            if (lv.start_pc == handlerpc + 1) {
   19.62 +            char ct = catchEntry[3];
   19.63 +            if (catchType == ct) {
   19.64                  return i;
   19.65              }
   19.66          }

    20.1 --- a/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Tue May 14 13:55:35 2013 -0700
    20.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Tue May 14 15:04:06 2013 -0700
    20.3 @@ -30,6 +30,8 @@
    20.4  import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
    20.5  import com.sun.tools.javac.util.List;
    20.6  import com.sun.tools.javac.code.*;
    20.7 +import com.sun.tools.javac.code.Attribute.TypeCompound;
    20.8 +import com.sun.tools.javac.code.Symbol.VarSymbol;
    20.9  import com.sun.tools.javac.comp.*;
   20.10  import com.sun.tools.javac.tree.*;
   20.11  
   20.12 @@ -47,7 +49,6 @@
   20.13  import static com.sun.tools.javac.jvm.CRTFlags.*;
   20.14  import static com.sun.tools.javac.main.Option.*;
   20.15  import static com.sun.tools.javac.tree.JCTree.Tag.*;
   20.16 -import static com.sun.tools.javac.tree.JCTree.Tag.BLOCK;
   20.17  
   20.18  /** This pass maps flat Java (i.e. without inner classes) to bytecodes.
   20.19   *
   20.20 @@ -308,7 +309,15 @@
   20.21       */
   20.22      int makeRef(DiagnosticPosition pos, Type type) {
   20.23          checkDimension(pos, type);
   20.24 -        return pool.put(type.hasTag(CLASS) ? (Object)type.tsym : (Object)type);
   20.25 +        if (type.isAnnotated()) {
   20.26 +            // Treat annotated types separately - we don't want
   20.27 +            // to collapse all of them - at least for annotated
   20.28 +            // exceptions.
   20.29 +            // TODO: review this.
   20.30 +            return pool.put((Object)type);
   20.31 +        } else {
   20.32 +            return pool.put(type.hasTag(CLASS) ? (Object)type.tsym : (Object)type);
   20.33 +        }
   20.34      }
   20.35  
   20.36      /** Check if the given type is an array with too many dimensions.
   20.37 @@ -456,7 +465,9 @@
   20.38       */
   20.39      List<JCTree> normalizeDefs(List<JCTree> defs, ClassSymbol c) {
   20.40          ListBuffer<JCStatement> initCode = new ListBuffer<JCStatement>();
   20.41 +        ListBuffer<Attribute.TypeCompound> initTAs = new ListBuffer<Attribute.TypeCompound>();
   20.42          ListBuffer<JCStatement> clinitCode = new ListBuffer<JCStatement>();
   20.43 +        ListBuffer<Attribute.TypeCompound> clinitTAs = new ListBuffer<Attribute.TypeCompound>();
   20.44          ListBuffer<JCTree> methodDefs = new ListBuffer<JCTree>();
   20.45          // Sort definitions into three listbuffers:
   20.46          //  - initCode for instance initializers
   20.47 @@ -486,6 +497,7 @@
   20.48                              Assignment(sym, vdef.init);
   20.49                          initCode.append(init);
   20.50                          endPosTable.replaceTree(vdef, init);
   20.51 +                        initTAs.addAll(getAndRemoveNonFieldTAs(sym));
   20.52                      } else if (sym.getConstValue() == null) {
   20.53                          // Initialize class (static) variables only if
   20.54                          // they are not compile-time constants.
   20.55 @@ -493,6 +505,7 @@
   20.56                              Assignment(sym, vdef.init);
   20.57                          clinitCode.append(init);
   20.58                          endPosTable.replaceTree(vdef, init);
   20.59 +                        clinitTAs.addAll(getAndRemoveNonFieldTAs(sym));
   20.60                      } else {
   20.61                          checkStringConstant(vdef.init.pos(), sym.getConstValue());
   20.62                      }
   20.63 @@ -505,8 +518,10 @@
   20.64          // Insert any instance initializers into all constructors.
   20.65          if (initCode.length() != 0) {
   20.66              List<JCStatement> inits = initCode.toList();
   20.67 +            initTAs.addAll(c.annotations.getInitTypeAttributes());
   20.68 +            List<Attribute.TypeCompound> initTAlist = initTAs.toList();
   20.69              for (JCTree t : methodDefs) {
   20.70 -                normalizeMethod((JCMethodDecl)t, inits);
   20.71 +                normalizeMethod((JCMethodDecl)t, inits, initTAlist);
   20.72              }
   20.73          }
   20.74          // If there are class initializers, create a <clinit> method
   20.75 @@ -524,11 +539,31 @@
   20.76              JCBlock block = make.at(clinitStats.head.pos()).Block(0, clinitStats);
   20.77              block.endpos = TreeInfo.endPos(clinitStats.last());
   20.78              methodDefs.append(make.MethodDef(clinit, block));
   20.79 +
   20.80 +            if (!clinitTAs.isEmpty())
   20.81 +                clinit.annotations.appendUniqueTypes(clinitTAs.toList());
   20.82 +            if (!c.annotations.getClassInitTypeAttributes().isEmpty())
   20.83 +                clinit.annotations.appendUniqueTypes(c.annotations.getClassInitTypeAttributes());
   20.84          }
   20.85          // Return all method definitions.
   20.86          return methodDefs.toList();
   20.87      }
   20.88  
   20.89 +    private List<Attribute.TypeCompound> getAndRemoveNonFieldTAs(VarSymbol sym) {
   20.90 +        List<TypeCompound> tas = sym.getRawTypeAttributes();
   20.91 +        ListBuffer<Attribute.TypeCompound> fieldTAs = new ListBuffer<Attribute.TypeCompound>();
   20.92 +        ListBuffer<Attribute.TypeCompound> nonfieldTAs = new ListBuffer<Attribute.TypeCompound>();
   20.93 +        for (TypeCompound ta : tas) {
   20.94 +            if (ta.position.type == TargetType.FIELD) {
   20.95 +                fieldTAs.add(ta);
   20.96 +            } else {
   20.97 +                nonfieldTAs.add(ta);
   20.98 +            }
   20.99 +        }
  20.100 +        sym.annotations.setTypeAttributes(fieldTAs.toList());
  20.101 +        return nonfieldTAs.toList();
  20.102 +    }
  20.103 +
  20.104      /** Check a constant value and report if it is a string that is
  20.105       *  too large.
  20.106       */
  20.107 @@ -546,8 +581,9 @@
  20.108       *  @param md        The tree potentially representing a
  20.109       *                   constructor's definition.
  20.110       *  @param initCode  The list of instance initializer statements.
  20.111 +     *  @param initTAs  Type annotations from the initializer expression.
  20.112       */
  20.113 -    void normalizeMethod(JCMethodDecl md, List<JCStatement> initCode) {
  20.114 +    void normalizeMethod(JCMethodDecl md, List<JCStatement> initCode, List<TypeCompound> initTAs) {
  20.115          if (md.name == names.init && TreeInfo.isInitialConstructor(md)) {
  20.116              // We are seeing a constructor that does not call another
  20.117              // constructor of the same class.
  20.118 @@ -581,6 +617,8 @@
  20.119              md.body.stats = newstats.toList();
  20.120              if (md.body.endpos == Position.NOPOS)
  20.121                  md.body.endpos = TreeInfo.endPos(md.body.stats.last());
  20.122 +
  20.123 +            md.sym.annotations.appendUniqueTypes(initTAs);
  20.124          }
  20.125      }
  20.126  
  20.127 @@ -1527,6 +1565,11 @@
  20.128                          registerCatch(tree.pos(),
  20.129                                        startpc,  end, code.curPc(),
  20.130                                        catchType);
  20.131 +                        if (subCatch.type.isAnnotated()) {
  20.132 +                            // All compounds share the same position, simply update the
  20.133 +                            // first one.
  20.134 +                            subCatch.type.getAnnotationMirrors().head.position.type_index = catchType;
  20.135 +                        }
  20.136                      }
  20.137                      gaps = gaps.tail;
  20.138                      startpc = gaps.head.intValue();
  20.139 @@ -1538,6 +1581,11 @@
  20.140                          registerCatch(tree.pos(),
  20.141                                        startpc, endpc, code.curPc(),
  20.142                                        catchType);
  20.143 +                        if (subCatch.type.isAnnotated()) {
  20.144 +                            // All compounds share the same position, simply update the
  20.145 +                            // first one.
  20.146 +                            subCatch.type.getAnnotationMirrors().head.position.type_index = catchType;
  20.147 +                        }
  20.148                      }
  20.149                  }
  20.150                  VarSymbol exparam = tree.param.sym;
  20.151 @@ -1783,42 +1831,44 @@
  20.152          result = items.makeStackItem(pt);
  20.153      }
  20.154  
  20.155 -   private void setTypeAnnotationPositions(int treePos) {
  20.156 -       MethodSymbol meth = code.meth;
  20.157 +    private void setTypeAnnotationPositions(int treePos) {
  20.158 +        MethodSymbol meth = code.meth;
  20.159 +        boolean initOrClinit = code.meth.getKind() == javax.lang.model.element.ElementKind.CONSTRUCTOR
  20.160 +                || code.meth.getKind() == javax.lang.model.element.ElementKind.STATIC_INIT;
  20.161  
  20.162 -       for (Attribute.TypeCompound ta : meth.getRawTypeAttributes()) {
  20.163 -           if (ta.position.pos == treePos) {
  20.164 -               ta.position.offset = code.cp;
  20.165 -               ta.position.lvarOffset = new int[] { code.cp };
  20.166 -               ta.position.isValidOffset = true;
  20.167 -           }
  20.168 -       }
  20.169 +        for (Attribute.TypeCompound ta : meth.getRawTypeAttributes()) {
  20.170 +            if (ta.hasUnknownPosition())
  20.171 +                ta.tryFixPosition();
  20.172  
  20.173 -       if (code.meth.getKind() != javax.lang.model.element.ElementKind.CONSTRUCTOR
  20.174 -               && code.meth.getKind() != javax.lang.model.element.ElementKind.STATIC_INIT)
  20.175 -           return;
  20.176 +            if (ta.position.matchesPos(treePos))
  20.177 +                ta.position.updatePosOffset(code.cp);
  20.178 +        }
  20.179  
  20.180 -       for (Attribute.TypeCompound ta : meth.owner.getRawTypeAttributes()) {
  20.181 -           if (ta.position.pos == treePos) {
  20.182 -               ta.position.offset = code.cp;
  20.183 -               ta.position.lvarOffset = new int[] { code.cp };
  20.184 -               ta.position.isValidOffset = true;
  20.185 -           }
  20.186 -       }
  20.187 +        if (!initOrClinit)
  20.188 +            return;
  20.189  
  20.190 -       ClassSymbol clazz = meth.enclClass();
  20.191 -       for (Symbol s : new com.sun.tools.javac.model.FilteredMemberList(clazz.members())) {
  20.192 -           if (!s.getKind().isField())
  20.193 -               continue;
  20.194 -           for (Attribute.TypeCompound ta : s.getRawTypeAttributes()) {
  20.195 -               if (ta.position.pos == treePos) {
  20.196 -                   ta.position.offset = code.cp;
  20.197 -                   ta.position.lvarOffset = new int[] { code.cp };
  20.198 -                   ta.position.isValidOffset = true;
  20.199 -               }
  20.200 -           }
  20.201 -       }
  20.202 -   }
  20.203 +        for (Attribute.TypeCompound ta : meth.owner.getRawTypeAttributes()) {
  20.204 +            if (ta.hasUnknownPosition())
  20.205 +                ta.tryFixPosition();
  20.206 +
  20.207 +            if (ta.position.matchesPos(treePos))
  20.208 +                ta.position.updatePosOffset(code.cp);
  20.209 +        }
  20.210 +
  20.211 +        ClassSymbol clazz = meth.enclClass();
  20.212 +        for (Symbol s : new com.sun.tools.javac.model.FilteredMemberList(clazz.members())) {
  20.213 +            if (!s.getKind().isField())
  20.214 +                continue;
  20.215 +
  20.216 +            for (Attribute.TypeCompound ta : s.getRawTypeAttributes()) {
  20.217 +                if (ta.hasUnknownPosition())
  20.218 +                    ta.tryFixPosition();
  20.219 +
  20.220 +                if (ta.position.matchesPos(treePos))
  20.221 +                    ta.position.updatePosOffset(code.cp);
  20.222 +            }
  20.223 +        }
  20.224 +    }
  20.225  
  20.226      public void visitNewClass(JCNewClass tree) {
  20.227          // Enclosing instances or anonymous classes should have been eliminated

    21.1 --- a/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Tue May 14 13:55:35 2013 -0700
    21.2 +++ b/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Tue May 14 15:04:06 2013 -0700
    21.3 @@ -25,7 +25,6 @@
    21.4  
    21.5  package com.sun.tools.javac.main;
    21.6  
    21.7 -import com.sun.tools.javac.comp.CompileStates;
    21.8  import java.io.*;
    21.9  import java.util.HashMap;
   21.10  import java.util.HashSet;
   21.11 @@ -55,6 +54,7 @@
   21.12  import com.sun.tools.javac.code.Lint.LintCategory;
   21.13  import com.sun.tools.javac.code.Symbol.*;
   21.14  import com.sun.tools.javac.comp.*;
   21.15 +import com.sun.tools.javac.comp.CompileStates.CompileState;
   21.16  import com.sun.tools.javac.file.JavacFileManager;
   21.17  import com.sun.tools.javac.jvm.*;
   21.18  import com.sun.tools.javac.parser.*;
   21.19 @@ -62,7 +62,6 @@
   21.20  import com.sun.tools.javac.tree.*;
   21.21  import com.sun.tools.javac.tree.JCTree.*;
   21.22  import com.sun.tools.javac.util.*;
   21.23 -import com.sun.tools.javac.comp.CompileStates.CompileState;
   21.24  import com.sun.tools.javac.util.Log.WriterKind;
   21.25  
   21.26  import static com.sun.tools.javac.code.TypeTag.CLASS;
   21.27 @@ -484,7 +483,7 @@
   21.28       */
   21.29      protected boolean werror;
   21.30  
   21.31 -    /** Switch: is annotation processing requested explitly via
   21.32 +    /** Switch: is annotation processing requested explicitly via
   21.33       * CompilationTask.setProcessors?
   21.34       */
   21.35      protected boolean explicitAnnotationProcessingRequested = false;

    22.1 --- a/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Tue May 14 13:55:35 2013 -0700
    22.2 +++ b/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Tue May 14 15:04:06 2013 -0700
    22.3 @@ -2013,7 +2013,7 @@
    22.4      /** Creator = [Annotations] Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
    22.5       */
    22.6      JCExpression creator(int newpos, List<JCExpression> typeArgs) {
    22.7 -        List<JCAnnotation> newAnnotations = typeAnnotationsOpt();
    22.8 +        List<JCAnnotation> newAnnotations = annotationsOpt(Tag.ANNOTATION);
    22.9  
   22.10          switch (token.kind) {
   22.11          case BYTE: case SHORT: case CHAR: case INT: case LONG: case FLOAT:
   22.12 @@ -2030,11 +2030,6 @@
   22.13          }
   22.14          JCExpression t = qualident(true);
   22.15  
   22.16 -        // handle type annotations for non primitive arrays
   22.17 -        if (newAnnotations.nonEmpty()) {
   22.18 -            t = insertAnnotationsToMostInner(t, newAnnotations, false);
   22.19 -        }
   22.20 -
   22.21          int oldmode = mode;
   22.22          mode = TYPE;
   22.23          boolean diamondFound = false;
   22.24 @@ -2068,6 +2063,11 @@
   22.25          }
   22.26          mode = oldmode;
   22.27          if (token.kind == LBRACKET || token.kind == MONKEYS_AT) {
   22.28 +            // handle type annotations for non primitive arrays
   22.29 +            if (newAnnotations.nonEmpty()) {
   22.30 +                t = insertAnnotationsToMostInner(t, newAnnotations, false);
   22.31 +            }
   22.32 +
   22.33              JCExpression e = arrayCreatorRest(newpos, t);
   22.34              if (diamondFound) {
   22.35                  reportSyntaxError(lastTypeargsPos, "cannot.create.array.with.diamond");
   22.36 @@ -2092,8 +2092,18 @@
   22.37              if (newClass.def != null) {
   22.38                  assert newClass.def.mods.annotations.isEmpty();
   22.39                  if (newAnnotations.nonEmpty()) {
   22.40 +                    // Add type and declaration annotations to the new class;
   22.41 +                    // com.sun.tools.javac.code.TypeAnnotations.TypeAnnotationPositions.visitNewClass(JCNewClass)
   22.42 +                    // will later remove all type annotations and only leave the
   22.43 +                    // declaration annotations.
   22.44                      newClass.def.mods.pos = earlier(newClass.def.mods.pos, newAnnotations.head.pos);
   22.45 -                    newClass.def.mods.annotations = List.convert(JCAnnotation.class, newAnnotations);
   22.46 +                    newClass.def.mods.annotations = newAnnotations;
   22.47 +                }
   22.48 +            } else {
   22.49 +                // handle type annotations for instantiations
   22.50 +                if (newAnnotations.nonEmpty()) {
   22.51 +                    t = insertAnnotationsToMostInner(t, newAnnotations, false);
   22.52 +                    newClass.clazz = t;
   22.53                  }
   22.54              }
   22.55              return newClass;
   22.56 @@ -2987,7 +2997,22 @@
   22.57              syntaxError(pos, "expected", IDENTIFIER);
   22.58              name = token.name();
   22.59          } else {
   22.60 -            name = ident();
   22.61 +            if (allowThisIdent) {
   22.62 +                JCExpression pn = qualident(false);
   22.63 +                if (pn.hasTag(Tag.IDENT) && ((JCIdent)pn).name != names._this) {
   22.64 +                    name = ((JCIdent)pn).name;
   22.65 +                } else {
   22.66 +                    if ((mods.flags & Flags.VARARGS) != 0) {
   22.67 +                        log.error(token.pos, "varargs.and.receiver");
   22.68 +                    }
   22.69 +                    if (token.kind == LBRACKET) {
   22.70 +                        log.error(token.pos, "array.and.receiver");
   22.71 +                    }
   22.72 +                    return toP(F.at(pos).ReceiverVarDef(mods, pn, type));
   22.73 +                }
   22.74 +            } else {
   22.75 +                name = ident();
   22.76 +            }
   22.77          }
   22.78          if ((mods.flags & Flags.VARARGS) != 0 &&
   22.79                  token.kind == LBRACKET) {
   22.80 @@ -3526,18 +3551,24 @@
   22.81          ListBuffer<JCExpression> ts = new ListBuffer<JCExpression>();
   22.82  
   22.83          List<JCAnnotation> typeAnnos = typeAnnotationsOpt();
   22.84 -        if (!typeAnnos.isEmpty())
   22.85 -            ts.append(toP(F.at(typeAnnos.head.pos).AnnotatedType(typeAnnos, qualident(true))));
   22.86 -        else
   22.87 -            ts.append(qualident(true));
   22.88 +        JCExpression qi = qualident(true);
   22.89 +        if (!typeAnnos.isEmpty()) {
   22.90 +            JCExpression at = insertAnnotationsToMostInner(qi, typeAnnos, false);
   22.91 +            ts.append(at);
   22.92 +        } else {
   22.93 +            ts.append(qi);
   22.94 +        }
   22.95          while (token.kind == COMMA) {
   22.96              nextToken();
   22.97  
   22.98              typeAnnos = typeAnnotationsOpt();
   22.99 -            if (!typeAnnos.isEmpty())
  22.100 -                ts.append(toP(F.at(typeAnnos.head.pos).AnnotatedType(typeAnnos, qualident(true))));
  22.101 -            else
  22.102 -                ts.append(qualident(true));
  22.103 +            qi = qualident(true);
  22.104 +            if (!typeAnnos.isEmpty()) {
  22.105 +                JCExpression at = insertAnnotationsToMostInner(qi, typeAnnos, false);
  22.106 +                ts.append(at);
  22.107 +            } else {
  22.108 +                ts.append(qi);
  22.109 +            }
  22.110          }
  22.111          return ts.toList();
  22.112      }
  22.113 @@ -3601,7 +3632,7 @@
  22.114          if (token.kind != RPAREN) {
  22.115              this.allowThisIdent = true;
  22.116              lastParam = formalParameter(lambdaParameters);
  22.117 -            if (lastParam.name.contentEquals(TokenKind.THIS.name)) {
  22.118 +            if (lastParam.nameexpr != null) {
  22.119                  this.receiverParam = lastParam;
  22.120              } else {
  22.121                  params.append(lastParam);

    23.1 --- a/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Tue May 14 13:55:35 2013 -0700
    23.2 +++ b/src/share/classes/com/sun/tools/javac/resources/compiler.properties	Tue May 14 15:04:06 2013 -0700
    23.3 @@ -221,7 +221,7 @@
    23.4      bad intersection type target for lambda or method reference\n\
    23.5      {0}
    23.6  
    23.7 -# 0: type
    23.8 +# 0: symbol or type
    23.9  compiler.misc.not.an.intf.component=\
   23.10      component type {0} is not an interface
   23.11  
   23.12 @@ -331,29 +331,29 @@
   23.13  
   23.14  # 0: type, 1: type
   23.15  compiler.err.duplicate.annotation.missing.container=\
   23.16 -    duplicate annotation, the declaration of {0} does not have a valid {1} annotation
   23.17 +    duplicate annotation: the declaration of {0} does not have a valid {1} annotation
   23.18  
   23.19  # 0: type
   23.20  compiler.err.invalid.repeatable.annotation=\
   23.21 -    duplicate annotation, {0} is annotated with an invalid Repeatable annotation
   23.22 -
   23.23 -# 0: type
   23.24 +    duplicate annotation: {0} is annotated with an invalid Repeatable annotation
   23.25 +
   23.26 +# 0: symbol or type
   23.27  compiler.err.invalid.repeatable.annotation.no.value=\
   23.28 -    duplicate annotation, {0} is not a valid Repeatable, no value element method declared
   23.29 +    duplicate annotation: {0} is not a valid Repeatable, no value element method declared
   23.30  
   23.31  # 0: type, 1: number
   23.32  compiler.err.invalid.repeatable.annotation.multiple.values=\
   23.33 -    duplicate annotation, {0} is not a valid Repeatable, {1} value element methods declared
   23.34 +    duplicate annotation: {0} is not a valid Repeatable, {1} value element methods declared
   23.35  
   23.36  # 0: type
   23.37  compiler.err.invalid.repeatable.annotation.invalid.value=\
   23.38 -    duplicate annotation, {0} is not a valid Repeatable, invalid value element, need a method
   23.39 -
   23.40 -# 0: type, 1: type, 2: type
   23.41 +    duplicate annotation: {0} is not a valid Repeatable: invalid value element
   23.42 +
   23.43 +# 0: symbol type, 1: type, 2: type
   23.44  compiler.err.invalid.repeatable.annotation.value.return=\
   23.45 -    duplicate annotation, value element of containing annotation {0} should have type {2}, found {1}
   23.46 -
   23.47 -# 0: type, 1: symbol
   23.48 +    duplicate annotation: value element of containing annotation {0} should have type {2}, found {1}
   23.49 +
   23.50 +# 0: symbol or type, 1: symbol
   23.51  compiler.err.invalid.repeatable.annotation.elem.nondefault=\
   23.52      containing annotation {0} does not have a default value for element {1}
   23.53  
   23.54 @@ -592,6 +592,12 @@
   23.55  compiler.err.varargs.and.old.array.syntax=\
   23.56      legacy array notation not allowed on variable-arity parameter
   23.57  
   23.58 +compiler.err.varargs.and.receiver =\
   23.59 +    varargs notation not allowed on receiver parameter
   23.60 +
   23.61 +compiler.err.array.and.receiver =\
   23.62 +    legacy array notation not allowed on receiver parameter
   23.63 +
   23.64  compiler.err.variable.not.allowed=\
   23.65      variable declaration not allowed here
   23.66  
   23.67 @@ -659,6 +665,7 @@
   23.68  compiler.err.missing.ret.stmt=\
   23.69      missing return statement
   23.70  
   23.71 +# 0: unused
   23.72  compiler.misc.missing.ret.val=\
   23.73      missing return value
   23.74  
   23.75 @@ -983,7 +990,7 @@
   23.76  compiler.misc.overridden.default=\
   23.77      method {0} is overridden in {1}
   23.78  
   23.79 -# 0: symbol, 1: symbol
   23.80 +# 0: symbol, 1: type or symbol
   23.81  compiler.misc.redundant.supertype=\
   23.82      redundant interface {0} is extended by {1}
   23.83  
   23.84 @@ -1896,11 +1903,10 @@
   23.85  
   23.86  #####
   23.87  
   23.88 -# 0: type, 1: file name
   23.89 +# 0: symbol or type, 1: file name
   23.90  compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file=\
   23.91      auxiliary class {0} in {1} should not be accessed from outside its own source file
   23.92  
   23.93 -
   23.94  ## The first argument ({0}) is a "kindname".
   23.95  # 0: symbol kind, 1: symbol, 2: symbol
   23.96  compiler.err.abstract.cant.be.accessed.directly=\
   23.97 @@ -2185,15 +2191,42 @@
   23.98  compiler.err.this.as.identifier=\
   23.99      as of release 8, ''this'' is allowed as the parameter name for the receiver type only, which has to be the first parameter
  23.100  
  23.101 +# 0: symbol
  23.102 +compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\
  23.103 +    receiver parameter not applicable for constructor of top-level class
  23.104 +
  23.105  # TODO 308: make a better error message
  23.106  compiler.err.cant.annotate.static.class=\
  23.107      enclosing static nested class cannot be annotated
  23.108 +
  23.109  # TODO 308: make a better error message
  23.110 +# 0: unused
  23.111  compiler.err.cant.annotate.nested.type=\
  23.112      nested type cannot be annotated
  23.113  
  23.114 +# 0: type, 1: type
  23.115 +compiler.err.incorrect.receiver.name=\
  23.116 +    the receiver name does not match the enclosing class type\n\
  23.117 +    required: {0}\n\
  23.118 +    found: {1}
  23.119 +
  23.120 +# 0: type, 1: type
  23.121  compiler.err.incorrect.receiver.type=\
  23.122 -    the receiver type does not match the enclosing class type
  23.123 +    the receiver type does not match the enclosing class type\n\
  23.124 +    required: {0}\n\
  23.125 +    found: {1}
  23.126 +
  23.127 +# 0: type, 1: type
  23.128 +compiler.err.incorrect.constructor.receiver.type=\
  23.129 +    the receiver type does not match the enclosing outer class type\n\
  23.130 +    required: {0}\n\
  23.131 +    found: {1}
  23.132 +
  23.133 +# 0: type, 1: type
  23.134 +compiler.err.incorrect.constructor.receiver.name=\
  23.135 +    the receiver name does not match the enclosing outer class type\n\
  23.136 +    required: {0}\n\
  23.137 +    found: {1}
  23.138  
  23.139  compiler.err.no.annotations.on.dot.class=\
  23.140      no annotations are allowed in the type of a class literal

    24.1 --- a/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Tue May 14 13:55:35 2013 -0700
    24.2 +++ b/src/share/classes/com/sun/tools/javac/tree/JCTree.java	Tue May 14 15:04:06 2013 -0700
    24.3 @@ -42,7 +42,6 @@
    24.4  import com.sun.tools.javac.util.*;
    24.5  import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
    24.6  import com.sun.tools.javac.util.List;
    24.7 -import static com.sun.tools.javac.code.BoundKind.*;
    24.8  import static com.sun.tools.javac.tree.JCTree.Tag.*;
    24.9  
   24.10  /**
   24.11 @@ -807,12 +806,15 @@
   24.12          public JCModifiers mods;
   24.13          /** variable name */
   24.14          public Name name;
   24.15 +        /** variable name expression */
   24.16 +        public JCExpression nameexpr;
   24.17          /** type of the variable */
   24.18          public JCExpression vartype;
   24.19          /** variable's initial value */
   24.20          public JCExpression init;
   24.21          /** symbol */
   24.22          public VarSymbol sym;
   24.23 +
   24.24          protected JCVariableDecl(JCModifiers mods,
   24.25                           Name name,
   24.26                           JCExpression vartype,
   24.27 @@ -824,12 +826,27 @@
   24.28              this.init = init;
   24.29              this.sym = sym;
   24.30          }
   24.31 +
   24.32 +        protected JCVariableDecl(JCModifiers mods,
   24.33 +                         JCExpression nameexpr,
   24.34 +                         JCExpression vartype) {
   24.35 +            this(mods, null, vartype, null, null);
   24.36 +            this.nameexpr = nameexpr;
   24.37 +            if (nameexpr.hasTag(Tag.IDENT)) {
   24.38 +                this.name = ((JCIdent)nameexpr).name;
   24.39 +            } else {
   24.40 +                // Only other option is qualified name x.y.this;
   24.41 +                this.name = ((JCFieldAccess)nameexpr).name;
   24.42 +            }
   24.43 +        }
   24.44 +
   24.45          @Override
   24.46          public void accept(Visitor v) { v.visitVarDef(this); }
   24.47  
   24.48          public Kind getKind() { return Kind.VARIABLE; }
   24.49          public JCModifiers getModifiers() { return mods; }
   24.50          public Name getName() { return name; }
   24.51 +        public JCExpression getNameExpression() { return nameexpr; }
   24.52          public JCTree getType() { return vartype; }
   24.53          public JCExpression getInitializer() {
   24.54              return init;
   24.55 @@ -845,7 +862,7 @@
   24.56          }
   24.57      }
   24.58  
   24.59 -      /**
   24.60 +    /**
   24.61       * A no-op statement ";".
   24.62       */
   24.63      public static class JCSkip extends JCStatement implements EmptyStatementTree {

    25.1 --- a/src/share/classes/com/sun/tools/javac/tree/Pretty.java	Tue May 14 13:55:35 2013 -0700
    25.2 +++ b/src/share/classes/com/sun/tools/javac/tree/Pretty.java	Tue May 14 15:04:06 2013 -0700
    25.3 @@ -261,8 +261,6 @@
    25.4      }
    25.5  
    25.6      public void printTypeAnnotations(List<JCAnnotation> trees) throws IOException {
    25.7 -        if (trees.nonEmpty())
    25.8 -            print(" ");
    25.9          for (List<JCAnnotation> l = trees; l.nonEmpty(); l = l.tail) {
   25.10              printExpr(l.head);
   25.11              print(" ");
   25.12 @@ -564,8 +562,10 @@
   25.13                          vartype = ((JCAnnotatedType)vartype).underlyingType;
   25.14                      }
   25.15                      printExpr(((JCArrayTypeTree) vartype).elemtype);
   25.16 -                    if (tas != null)
   25.17 +                    if (tas != null) {
   25.18 +                        print(' ');
   25.19                          printTypeAnnotations(tas);
   25.20 +                    }
   25.21                      print("... " + tree.name);
   25.22                  } else {
   25.23                      printExpr(tree.vartype);
   25.24 @@ -918,6 +918,9 @@
   25.25                  printExprs(tree.typeargs);
   25.26                  print(">");
   25.27              }
   25.28 +            if (tree.def != null && tree.def.mods.annotations.nonEmpty()) {
   25.29 +                printTypeAnnotations(tree.def.mods.annotations);
   25.30 +            }
   25.31              printExpr(tree.clazz);
   25.32              print("(");
   25.33              printExprs(tree.args);
   25.34 @@ -948,7 +951,8 @@
   25.35                  int i = 0;
   25.36                  List<List<JCAnnotation>> da = tree.dimAnnotations;
   25.37                  for (List<JCExpression> l = tree.dims; l.nonEmpty(); l = l.tail) {
   25.38 -                    if (da.size() > i) {
   25.39 +                    if (da.size() > i && !da.get(i).isEmpty()) {
   25.40 +                        print(' ');
   25.41                          printTypeAnnotations(da.get(i));
   25.42                      }
   25.43                      print("[");
   25.44 @@ -958,6 +962,7 @@
   25.45                  }
   25.46                  if (tree.elems != null) {
   25.47                      if (isElemAnnoType) {
   25.48 +                        print(' ');
   25.49                          printTypeAnnotations(((JCAnnotatedType)tree.elemtype).annotations);
   25.50                      }
   25.51                      print("[]");
   25.52 @@ -1264,6 +1269,7 @@
   25.53                  JCAnnotatedType atype = (JCAnnotatedType) elem;
   25.54                  elem = atype.underlyingType;
   25.55                  if (!elem.hasTag(TYPEARRAY)) break;
   25.56 +                print(' ');
   25.57                  printTypeAnnotations(atype.annotations);
   25.58              }
   25.59              print("[]");
   25.60 @@ -1301,6 +1307,9 @@
   25.61  
   25.62      public void visitTypeParameter(JCTypeParameter tree) {
   25.63          try {
   25.64 +            if (tree.annotations.nonEmpty()) {
   25.65 +                this.printTypeAnnotations(tree.annotations);
   25.66 +            }
   25.67              print(tree.name);
   25.68              if (tree.bounds.nonEmpty()) {
   25.69                  print(" extends ");
   25.70 @@ -1379,6 +1388,7 @@
   25.71              } else if (tree.underlyingType.getKind() == JCTree.Kind.ARRAY_TYPE) {
   25.72                  JCArrayTypeTree array = (JCArrayTypeTree) tree.underlyingType;
   25.73                  printBaseElementType(tree);
   25.74 +                print(' ');
   25.75                  printTypeAnnotations(tree.annotations);
   25.76                  print("[]");
   25.77                  JCExpression elem = array.elemtype;

    26.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeCopier.java	Tue May 14 13:55:35 2013 -0700
    26.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeCopier.java	Tue May 14 15:04:06 2013 -0700
    26.3 @@ -422,8 +422,13 @@
    26.4          JCVariableDecl t = (JCVariableDecl) node;
    26.5          JCModifiers mods = copy(t.mods, p);
    26.6          JCExpression vartype = copy(t.vartype, p);
    26.7 -        JCExpression init = copy(t.init, p);
    26.8 -        return M.at(t.pos).VarDef(mods, t.name, vartype, init);
    26.9 +        if (t.nameexpr == null) {
   26.10 +            JCExpression init = copy(t.init, p);
   26.11 +            return M.at(t.pos).VarDef(mods, t.name, vartype, init);
   26.12 +        } else {
   26.13 +            JCExpression nameexpr = copy(t.nameexpr, p);
   26.14 +            return M.at(t.pos).ReceiverVarDef(mods, nameexpr, vartype);
   26.15 +        }
   26.16      }
   26.17  
   26.18      public JCTree visitWhileLoop(WhileLoopTree node, P p) {

    27.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java	Tue May 14 13:55:35 2013 -0700
    27.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeMaker.java	Tue May 14 15:04:06 2013 -0700
    27.3 @@ -204,6 +204,12 @@
    27.4          return tree;
    27.5      }
    27.6  
    27.7 +    public JCVariableDecl ReceiverVarDef(JCModifiers mods, JCExpression name, JCExpression vartype) {
    27.8 +        JCVariableDecl tree = new JCVariableDecl(mods, name, vartype);
    27.9 +        tree.pos = pos;
   27.10 +        return tree;
   27.11 +    }
   27.12 +
   27.13      public JCSkip Skip() {
   27.14          JCSkip tree = new JCSkip();
   27.15          tree.pos = pos;

    28.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeScanner.java	Tue May 14 13:55:35 2013 -0700
    28.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeScanner.java	Tue May 14 15:04:06 2013 -0700
    28.3 @@ -94,6 +94,7 @@
    28.4      public void visitVarDef(JCVariableDecl tree) {
    28.5          scan(tree.mods);
    28.6          scan(tree.vartype);
    28.7 +        scan(tree.nameexpr);
    28.8          scan(tree.init);
    28.9      }
   28.10  

    29.1 --- a/src/share/classes/com/sun/tools/javac/tree/TreeTranslator.java	Tue May 14 13:55:35 2013 -0700
    29.2 +++ b/src/share/classes/com/sun/tools/javac/tree/TreeTranslator.java	Tue May 14 15:04:06 2013 -0700
    29.3 @@ -148,6 +148,7 @@
    29.4  
    29.5      public void visitVarDef(JCVariableDecl tree) {
    29.6          tree.mods = translate(tree.mods);
    29.7 +        tree.nameexpr = translate(tree.nameexpr);
    29.8          tree.vartype = translate(tree.vartype);
    29.9          tree.init = translate(tree.init);
   29.10          result = tree;

    30.1 --- a/src/share/classes/com/sun/tools/javac/util/List.java	Tue May 14 13:55:35 2013 -0700
    30.2 +++ b/src/share/classes/com/sun/tools/javac/util/List.java	Tue May 14 15:04:06 2013 -0700
    30.3 @@ -1,5 +1,5 @@
    30.4  /*
    30.5 - * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
    30.6 + * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
    30.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    30.8   *
    30.9   * This code is free software; you can redistribute it and/or modify it
   30.10 @@ -37,7 +37,7 @@
   30.11  /** A class for generic linked lists. Links are supposed to be
   30.12   *  immutable, the only exception being the incremental construction of
   30.13   *  lists via ListBuffers.  List is the main container class in
   30.14 - *  GJC. Most data structures and algorthms in GJC use lists rather
   30.15 + *  GJC. Most data structures and algorithms in GJC use lists rather
   30.16   *  than arrays.
   30.17   *
   30.18   *  <p>Lists are always trailed by a sentinel element, whose head and tail

    31.1 --- a/src/share/classes/com/sun/tools/javadoc/AnnotationTypeDocImpl.java	Tue May 14 13:55:35 2013 -0700
    31.2 +++ b/src/share/classes/com/sun/tools/javadoc/AnnotationTypeDocImpl.java	Tue May 14 15:04:06 2013 -0700
    31.3 @@ -1,5 +1,5 @@
    31.4  /*
    31.5 - * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
    31.6 + * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
    31.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    31.8   *
    31.9   * This code is free software; you can redistribute it and/or modify it
   31.10 @@ -31,9 +31,7 @@
   31.11  import com.sun.tools.javac.code.Kinds;
   31.12  import com.sun.tools.javac.code.Scope;
   31.13  import com.sun.tools.javac.code.Symbol.*;
   31.14 -import com.sun.tools.javac.tree.JCTree.*;
   31.15  import com.sun.tools.javac.util.List;
   31.16 -import com.sun.tools.javac.util.Names;
   31.17  
   31.18  /**
   31.19   * Represents an annotation type.
   31.20 @@ -92,7 +90,6 @@
   31.21       * Elements are always public, so no need to filter them.
   31.22       */
   31.23      public AnnotationTypeElementDoc[] elements() {
   31.24 -        Names names = tsym.name.table.names;
   31.25          List<AnnotationTypeElementDoc> elements = List.nil();
   31.26          for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
   31.27              if (e.sym != null && e.sym.kind == Kinds.MTH) {

    32.1 --- a/src/share/classes/com/sun/tools/javadoc/AnnotationTypeElementDocImpl.java	Tue May 14 13:55:35 2013 -0700
    32.2 +++ b/src/share/classes/com/sun/tools/javadoc/AnnotationTypeElementDocImpl.java	Tue May 14 15:04:06 2013 -0700
    32.3 @@ -1,5 +1,5 @@
    32.4  /*
    32.5 - * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
    32.6 + * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
    32.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    32.8   *
    32.9   * This code is free software; you can redistribute it and/or modify it
   32.10 @@ -29,7 +29,6 @@
   32.11  
   32.12  import com.sun.source.util.TreePath;
   32.13  import com.sun.tools.javac.code.Symbol.*;
   32.14 -import com.sun.tools.javac.tree.JCTree.*;
   32.15  
   32.16  /**
   32.17   * Represents an element of an annotation type.

    33.1 --- a/src/share/classes/com/sun/tools/javadoc/AnnotationValueImpl.java	Tue May 14 13:55:35 2013 -0700
    33.2 +++ b/src/share/classes/com/sun/tools/javadoc/AnnotationValueImpl.java	Tue May 14 15:04:06 2013 -0700
    33.3 @@ -1,5 +1,5 @@
    33.4  /*
    33.5 - * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
    33.6 + * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
    33.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    33.8   *
    33.9   * This code is free software; you can redistribute it and/or modify it
   33.10 @@ -28,7 +28,6 @@
   33.11  import com.sun.javadoc.*;
   33.12  
   33.13  import com.sun.tools.javac.code.Attribute;
   33.14 -import com.sun.tools.javac.code.Symbol.*;
   33.15  
   33.16  import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
   33.17  

    34.1 --- a/src/share/classes/com/sun/tools/javadoc/ExecutableMemberDocImpl.java	Tue May 14 13:55:35 2013 -0700
    34.2 +++ b/src/share/classes/com/sun/tools/javadoc/ExecutableMemberDocImpl.java	Tue May 14 15:04:06 2013 -0700
    34.3 @@ -28,14 +28,10 @@
    34.4  import java.lang.reflect.Modifier;
    34.5  import java.text.CollationKey;
    34.6  
    34.7 -import javax.lang.model.type.TypeKind;
    34.8 -
    34.9  import com.sun.javadoc.*;
   34.10  
   34.11  import com.sun.source.util.TreePath;
   34.12 -import com.sun.tools.javac.code.Attribute;
   34.13  import com.sun.tools.javac.code.Flags;
   34.14 -import com.sun.tools.javac.code.Attribute.Compound;
   34.15  import com.sun.tools.javac.code.Symbol.*;
   34.16  import com.sun.tools.javac.code.Type;
   34.17  import com.sun.tools.javac.util.List;

    35.1 --- a/src/share/classes/com/sun/tools/javadoc/FieldDocImpl.java	Tue May 14 13:55:35 2013 -0700
    35.2 +++ b/src/share/classes/com/sun/tools/javadoc/FieldDocImpl.java	Tue May 14 15:04:06 2013 -0700
    35.3 @@ -34,10 +34,6 @@
    35.4  import com.sun.tools.javac.code.Symbol.ClassSymbol;
    35.5  import com.sun.tools.javac.code.Symbol.VarSymbol;
    35.6  
    35.7 -import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
    35.8 -
    35.9 -import com.sun.tools.javac.util.Position;
   35.10 -
   35.11  import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
   35.12  
   35.13  /**

    36.1 --- a/src/share/classes/com/sun/tools/javadoc/JavadocEnter.java	Tue May 14 13:55:35 2013 -0700
    36.2 +++ b/src/share/classes/com/sun/tools/javadoc/JavadocEnter.java	Tue May 14 15:04:06 2013 -0700
    36.3 @@ -1,5 +1,5 @@
    36.4  /*
    36.5 - * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
    36.6 + * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
    36.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    36.8   *
    36.9   * This code is free software; you can redistribute it and/or modify it
   36.10 @@ -25,10 +25,8 @@
   36.11  
   36.12  package com.sun.tools.javadoc;
   36.13  
   36.14 -
   36.15  import javax.tools.JavaFileObject;
   36.16  
   36.17 -import com.sun.source.util.TreePath;
   36.18  import com.sun.tools.javac.code.Kinds;
   36.19  import com.sun.tools.javac.code.Symbol.*;
   36.20  import com.sun.tools.javac.comp.Enter;

    37.1 --- a/src/share/classes/com/sun/tools/javadoc/Messager.java	Tue May 14 13:55:35 2013 -0700
    37.2 +++ b/src/share/classes/com/sun/tools/javadoc/Messager.java	Tue May 14 15:04:06 2013 -0700
    37.3 @@ -26,9 +26,7 @@
    37.4  package com.sun.tools.javadoc;
    37.5  
    37.6  import java.io.PrintWriter;
    37.7 -import java.text.MessageFormat;
    37.8  import java.util.Locale;
    37.9 -import java.util.ResourceBundle;
   37.10  
   37.11  import com.sun.javadoc.*;
   37.12  import com.sun.tools.javac.util.Context;

    38.1 --- a/src/share/classes/com/sun/tools/javadoc/TypeMaker.java	Tue May 14 13:55:35 2013 -0700
    38.2 +++ b/src/share/classes/com/sun/tools/javadoc/TypeMaker.java	Tue May 14 15:04:06 2013 -0700
    38.3 @@ -25,8 +25,6 @@
    38.4  
    38.5  package com.sun.tools.javadoc;
    38.6  
    38.7 -import javax.lang.model.type.TypeKind;
    38.8 -
    38.9  import com.sun.javadoc.*;
   38.10  import com.sun.tools.javac.code.Symbol;
   38.11  import com.sun.tools.javac.code.Symbol.ClassSymbol;
   38.12 @@ -64,12 +62,9 @@
   38.13          if (env.legacyDoclet) {
   38.14              t = env.types.erasure(t);
   38.15          }
   38.16 -        if (considerAnnotations
   38.17 -                && t.isAnnotated()) {
   38.18 -            return new AnnotatedTypeImpl(env, (com.sun.tools.javac.code.Type.AnnotatedType) t);
   38.19 -        }
   38.20  
   38.21 -        if (t.isAnnotated()) {
   38.22 +        if (considerAnnotations &&
   38.23 +                t.isAnnotated()) {
   38.24              Type.AnnotatedType at = (Type.AnnotatedType) t;
   38.25              return new AnnotatedTypeImpl(env, at);
   38.26          }

    39.1 --- a/src/share/classes/com/sun/tools/javadoc/TypeVariableImpl.java	Tue May 14 13:55:35 2013 -0700
    39.2 +++ b/src/share/classes/com/sun/tools/javadoc/TypeVariableImpl.java	Tue May 14 15:04:06 2013 -0700
    39.3 @@ -25,8 +25,6 @@
    39.4  
    39.5  package com.sun.tools.javadoc;
    39.6  
    39.7 -import javax.lang.model.type.TypeKind;
    39.8 -
    39.9  import com.sun.javadoc.*;
   39.10  
   39.11  import com.sun.tools.javac.code.Attribute;

    40.1 --- a/test/com/sun/javadoc/testTypeAnnotations/TestTypeAnnotations.java	Tue May 14 13:55:35 2013 -0700
    40.2 +++ b/test/com/sun/javadoc/testTypeAnnotations/TestTypeAnnotations.java	Tue May 14 15:04:06 2013 -0700
    40.3 @@ -45,7 +45,6 @@
    40.4      private static final String[][] NEGATED_TEST = NO_TEST;
    40.5      private static final String[][] TEST = {
    40.6          // Test for type annotations on Class Extends (ClassExtends.java).
    40.7 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
    40.8          {BUG_ID + FS + "typeannos" + FS + "MyClass.html",
    40.9              "extends <a href=\"../typeannos/ClassExtA.html\" title=\"annotation " +
   40.10              "in typeannos\">@ClassExtA</a> <a href=\"../typeannos/ParameterizedClass.html\" " +
   40.11 @@ -53,8 +52,6 @@
   40.12              "../typeannos/ClassExtB.html\" title=\"annotation in typeannos\">" +
   40.13              "@ClassExtB</a> java.lang.String&gt;"
   40.14          },
   40.15 -        */
   40.16 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
   40.17          {BUG_ID + FS + "typeannos" + FS + "MyClass.html",
   40.18              "implements <a href=\"../typeannos/ClassExtB.html\" title=\"" +
   40.19              "annotation in typeannos\">@ClassExtB</a> java.lang.CharSequence, " +
   40.20 @@ -64,8 +61,6 @@
   40.21              "<a href=\"../typeannos/ClassExtB.html\" title=\"annotation in " +
   40.22              "typeannos\">@ClassExtB</a> java.lang.String&gt;</pre>"
   40.23          },
   40.24 -        */
   40.25 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
   40.26          {BUG_ID + FS + "typeannos" + FS + "MyInterface.html",
   40.27              "extends <a href=\"../typeannos/ClassExtA.html\" title=\"annotation " +
   40.28              "in typeannos\">@ClassExtA</a> <a href=\"../typeannos/" +
   40.29 @@ -75,7 +70,6 @@
   40.30              "<a href=\"../typeannos/ClassExtB.html\" title=\"annotation in " +
   40.31              "typeannos\">@ClassExtB</a> java.lang.CharSequence</pre>"
   40.32          },
   40.33 -        */
   40.34  
   40.35          // Test for type annotations on Class Parameters (ClassParameters.java).
   40.36          {BUG_ID + FS + "typeannos" + FS + "ExtendsBound.html",
   40.37 @@ -83,7 +77,6 @@
   40.38              "href=\"../typeannos/ClassParamA.html\" title=\"annotation in " +
   40.39              "typeannos\">@ClassParamA</a> java.lang.String&gt;</span>"
   40.40          },
   40.41 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
   40.42          {BUG_ID + FS + "typeannos" + FS + "ExtendsGeneric.html",
   40.43              "<pre> class <span class=\"strong\">ExtendsGeneric&lt;K extends " +
   40.44              "<a href=\"../typeannos/ClassParamA.html\" title=\"annotation in " +
   40.45 @@ -92,7 +85,6 @@
   40.46              "../typeannos/ClassParamB.html\" title=\"annotation in typeannos\">" +
   40.47              "@ClassParamB</a> java.lang.String&gt;&gt;</span>"
   40.48          },
   40.49 -        */
   40.50          {BUG_ID + FS + "typeannos" + FS + "TwoBounds.html",
   40.51              "<pre> class <span class=\"strong\">TwoBounds&lt;K extends <a href=\"" +
   40.52              "../typeannos/ClassParamA.html\" title=\"annotation in typeannos\">" +
   40.53 @@ -119,7 +111,6 @@
   40.54          },
   40.55  
   40.56          // Test for type annotations on fields (Fields.java).
   40.57 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
   40.58          {BUG_ID + FS + "typeannos" + FS + "DefaultScope.html",
   40.59              "<pre><a href=\"../typeannos/Parameterized.html\" title=\"class in " +
   40.60              "typeannos\">Parameterized</a>&lt;<a href=\"../typeannos/FldA.html\" " +
   40.61 @@ -127,7 +118,6 @@
   40.62              "href=\"../typeannos/FldB.html\" title=\"annotation in typeannos\">" +
   40.63              "@FldB</a> java.lang.String&gt; bothTypeArgs</pre>"
   40.64          },
   40.65 -        */
   40.66          {BUG_ID + FS + "typeannos" + FS + "DefaultScope.html",
   40.67              "<pre><a href=\"../typeannos/FldA.html\" title=\"annotation in " +
   40.68              "typeannos\">@FldA</a> java.lang.String <a href=\"../typeannos/" +
   40.69 @@ -147,7 +137,6 @@
   40.70              "typeannos\">@FldC</a> <a href=\"../typeannos/FldB.html\" title=\"" +
   40.71              "annotation in typeannos\">@FldB</a> [] array2Deep</pre>"
   40.72          },
   40.73 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
   40.74          {BUG_ID + FS + "typeannos" + FS + "ModifiedScoped.html",
   40.75              "<pre>public final&nbsp;<a href=\"../typeannos/Parameterized.html\" " +
   40.76              "title=\"class in typeannos\">Parameterized</a>&lt;<a href=\"../" +
   40.77 @@ -160,7 +149,6 @@
   40.78              "title=\"annotation in typeannos\">@FldB</a> java.lang.String&gt; " +
   40.79              "nestedParameterized</pre>"
   40.80          },
   40.81 -        */
   40.82          {BUG_ID + FS + "typeannos" + FS + "ModifiedScoped.html",
   40.83              "<pre>public final&nbsp;<a href=\"../typeannos/FldA.html\" " +
   40.84              "title=\"annotation in typeannos\">@FldA</a> java.lang.String[][] " +
   40.85 @@ -184,7 +172,6 @@
   40.86              "<pre><a href=\"../typeannos/MRtnA.html\" title=\"annotation in " +
   40.87              "typeannos\">@MRtnA</a> java.lang.String[][]&nbsp;array2()</pre>"
   40.88          },
   40.89 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
   40.90          {BUG_ID + FS + "typeannos" + FS + "MtdModifiedScoped.html",
   40.91              "<pre>public final&nbsp;<a href=\"../typeannos/MtdParameterized.html\" " +
   40.92              "title=\"class in typeannos\">MtdParameterized</a>&lt;<a href=\"../" +
   40.93 @@ -197,7 +184,6 @@
   40.94              "MRtnB.html\" title=\"annotation in typeannos\">@MRtnB</a> java." +
   40.95              "lang.String&gt;&nbsp;nestedMtdParameterized()</pre>"
   40.96          },
   40.97 -        */
   40.98  
   40.99          // Test for type annotations on method type parameters (MethodTypeParameters.java).
  40.100          {BUG_ID + FS + "typeannos" + FS + "UnscopedUnmodified.html",
  40.101 @@ -205,7 +191,6 @@
  40.102              "annotation in typeannos\">@MTyParamA</a> java.lang.String&gt;" +
  40.103              "&nbsp;void&nbsp;methodExtends()</pre>"
  40.104          },
  40.105 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
  40.106          {BUG_ID + FS + "typeannos" + FS + "UnscopedUnmodified.html",
  40.107              "<pre>&lt;K extends <a href=\"../typeannos/MTyParamA.html\" title=\"" +
  40.108              "annotation in typeannos\">@MTyParamA</a> <a href=\"../typeannos/" +
  40.109 @@ -214,13 +199,11 @@
  40.110              "title=\"annotation in typeannos\">@MTyParamB</a> java.lang.String" +
  40.111              "&gt;&gt;&nbsp;void&nbsp;nestedExtends()</pre>"
  40.112          },
  40.113 -        */
  40.114          {BUG_ID + FS + "typeannos" + FS + "PublicModifiedMethods.html",
  40.115              "<pre>public final&nbsp;&lt;K extends <a href=\"../typeannos/" +
  40.116              "MTyParamA.html\" title=\"annotation in typeannos\">@MTyParamA</a> " +
  40.117              "java.lang.String&gt;&nbsp;void&nbsp;methodExtends()</pre>"
  40.118          },
  40.119 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
  40.120          {BUG_ID + FS + "typeannos" + FS + "PublicModifiedMethods.html",
  40.121              "<pre>public final&nbsp;&lt;K extends <a href=\"../typeannos/" +
  40.122              "MTyParamA.html\" title=\"annotation in typeannos\">@MTyParamA</a> " +
  40.123 @@ -231,7 +214,6 @@
  40.124              "title=\"annotation in typeannos\">@MTyParamB</a> java.lang.String" +
  40.125              "&gt;&gt;&nbsp;void&nbsp;dual()</pre>"
  40.126          },
  40.127 -        */
  40.128  
  40.129          // Test for type annotations on parameters (Parameters.java).
  40.130          {BUG_ID + FS + "typeannos" + FS + "Parameters.html",
  40.131 @@ -240,7 +222,6 @@
  40.132              "ParaParameterized</a>&lt;java.lang.String,java.lang.String&gt;" +
  40.133              "&nbsp;a)</pre>"
  40.134          },
  40.135 -        /* @ignore 8012173: javadoc does not receive all type annotations information from javac
  40.136          {BUG_ID + FS + "typeannos" + FS + "Parameters.html",
  40.137              "<pre>void&nbsp;nestedParaParameterized(<a href=\"../typeannos/" +
  40.138              "ParaParameterized.html\" title=\"class in typeannos\">" +
  40.139 @@ -254,7 +235,6 @@
  40.140              "typeannos/ParamB.html\" title=\"annotation in typeannos\">@ParamB" +
  40.141              "</a> java.lang.String&gt;&nbsp;a)</pre>"
  40.142          },
  40.143 -        */
  40.144          {BUG_ID + FS + "typeannos" + FS + "Parameters.html",
  40.145              "<pre>void&nbsp;array2Deep(<a href=\"../typeannos/ParamA.html\" " +
  40.146              "title=\"annotation in typeannos\">@ParamA</a> java.lang.String " +

    41.1 --- a/test/com/sun/javadoc/typeAnnotations/smoke/TestSmoke.java	Tue May 14 13:55:35 2013 -0700
    41.2 +++ b/test/com/sun/javadoc/typeAnnotations/smoke/TestSmoke.java	Tue May 14 15:04:06 2013 -0700
    41.3 @@ -24,7 +24,7 @@
    41.4  /*
    41.5   * @test
    41.6   * @bug 8006735
    41.7 - * @summary  Smoke test for ensuring that annotations are emited to javadoc
    41.8 + * @summary  Smoke test for ensuring that annotations are emitted to javadoc
    41.9   *
   41.10   * @author   Mahmood Ali <mali>
   41.11   * @library  ../../lib/
   41.12 @@ -46,37 +46,35 @@
   41.13      //Input for string search tests.
   41.14      private static final String[][] TEST = {
   41.15          {BUG_ID + FS + "pkg" + FS + "T0x1C.html", "@DA"},
   41.16 -        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.17          {BUG_ID + FS + "pkg" + FS + "T0x1D.html", "@DA"},
   41.18 -        */
   41.19 -        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.20          {BUG_ID + FS + "pkg" + FS + "T0x0D.html", "@DA"},
   41.21 -        */
   41.22          {BUG_ID + FS + "pkg" + FS + "T0x06.html", "@DA"},
   41.23 -        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.24          {BUG_ID + FS + "pkg" + FS + "T0x0B.html", "@DA"},
   41.25 -        */
   41.26 -        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.27          {BUG_ID + FS + "pkg" + FS + "T0x0F.html", "@DA"},
   41.28 -        */
   41.29          /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.30          {BUG_ID + FS + "pkg" + FS + "T0x20.html", "@DA"},
   41.31          */
   41.32          /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.33 +        {BUG_ID + FS + "pkg" + FS + "T0x20A.html", "@DTPA"},
   41.34 +        */
   41.35 +        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.36 +        {BUG_ID + FS + "pkg" + FS + "T0x20B.html", "@DA"},
   41.37 +        */
   41.38 +        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.39          {BUG_ID + FS + "pkg" + FS + "T0x22.html", "@DA"},
   41.40          */
   41.41 +        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.42 +        {BUG_ID + FS + "pkg" + FS + "T0x22A.html", "@DTPA"},
   41.43 +        */
   41.44 +        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.45 +        {BUG_ID + FS + "pkg" + FS + "T0x22B.html", "@DA"},
   41.46 +        */
   41.47          {BUG_ID + FS + "pkg" + FS + "T0x10.html", "@DA"},
   41.48          {BUG_ID + FS + "pkg" + FS + "T0x10A.html", "@DA"},
   41.49          {BUG_ID + FS + "pkg" + FS + "T0x12.html", "@DA"},
   41.50 -        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.51          {BUG_ID + FS + "pkg" + FS + "T0x11.html", "@DA"},
   41.52 -        */
   41.53 -        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.54          {BUG_ID + FS + "pkg" + FS + "T0x13.html", "@DA"},
   41.55 -        */
   41.56 -        /* @ignore 8013406: Test cases fail in javadoc test TestSmoke.java
   41.57          {BUG_ID + FS + "pkg" + FS + "T0x15.html", "@DA"},
   41.58 -        */
   41.59          {BUG_ID + FS + "pkg" + FS + "T0x14.html", "@DA"},
   41.60          {BUG_ID + FS + "pkg" + FS + "T0x16.html", "@DA"}
   41.61      };
   41.62 @@ -94,7 +92,11 @@
   41.63          {BUG_ID + FS + "pkg" + FS + "T0x0B.html", "@A"},
   41.64          {BUG_ID + FS + "pkg" + FS + "T0x0F.html", "@A"},
   41.65          {BUG_ID + FS + "pkg" + FS + "T0x20.html", "@A"},
   41.66 +        {BUG_ID + FS + "pkg" + FS + "T0x20A.html", "@A"},
   41.67 +        {BUG_ID + FS + "pkg" + FS + "T0x20B.html", "@A"},
   41.68          {BUG_ID + FS + "pkg" + FS + "T0x22.html", "@A"},
   41.69 +        {BUG_ID + FS + "pkg" + FS + "T0x22A.html", "@A"},
   41.70 +        {BUG_ID + FS + "pkg" + FS + "T0x22B.html", "@A"},
   41.71          {BUG_ID + FS + "pkg" + FS + "T0x10.html", "@A"},
   41.72          {BUG_ID + FS + "pkg" + FS + "T0x10A.html", "@A"},
   41.73          {BUG_ID + FS + "pkg" + FS + "T0x12.html", "@A"},

    42.1 --- a/test/com/sun/javadoc/typeAnnotations/smoke/pkg/TargetTypes.java	Tue May 14 13:55:35 2013 -0700
    42.2 +++ b/test/com/sun/javadoc/typeAnnotations/smoke/pkg/TargetTypes.java	Tue May 14 15:04:06 2013 -0700
    42.3 @@ -1,5 +1,5 @@
    42.4  /*
    42.5 - * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
    42.6 + * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    42.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    42.8   *
    42.9   * This code is free software; you can redistribute it and/or modify it
   42.10 @@ -36,24 +36,19 @@
   42.11   * @author Yuri Gaevsky
   42.12   */
   42.13  
   42.14 -@Target({TYPE_USE})
   42.15 +@Target(TYPE_USE)
   42.16  @Retention(RetentionPolicy.RUNTIME)
   42.17  @interface A {}
   42.18  
   42.19 -@Target({TYPE_USE})
   42.20 +@Target(TYPE_USE)
   42.21  @Retention(RetentionPolicy.RUNTIME)
   42.22  @Documented
   42.23  @interface DA {}
   42.24  
   42.25 -/** wildcard bound */
   42.26 -class T0x1C {
   42.27 -    void m0x1C(List<? extends @A @DA String> lst) {}
   42.28 -}
   42.29 -
   42.30 -/** wildcard bound generic/array */
   42.31 -class T0x1D<T> {
   42.32 -    void m0x1D(List<? extends @A @DA List<int[]>> lst) {}
   42.33 -}
   42.34 +@Target(TYPE_PARAMETER)
   42.35 +@Retention(RetentionPolicy.RUNTIME)
   42.36 +@Documented
   42.37 +@interface DTPA {}
   42.38  
   42.39  /** typecast */
   42.40  class T0x00 {
   42.41 @@ -76,6 +71,13 @@
   42.42      }
   42.43  }
   42.44  
   42.45 +/** type test (instanceof) generic/array */
   42.46 +class T0x03<T> {
   42.47 +    void m0x03(T typeObj, Object obj) {
   42.48 +        boolean ok = obj instanceof String @A @DA [];
   42.49 +    }
   42.50 +}
   42.51 +
   42.52  /** object creation (new) */
   42.53  class T0x04 {
   42.54      void m0x04() {
   42.55 @@ -83,80 +85,22 @@
   42.56      }
   42.57  }
   42.58  
   42.59 -/** local variable */
   42.60 -class T0x08 {
   42.61 -    void m0x08() {
   42.62 -      @A @DA String s = null;
   42.63 +/** object creation (new) generic/array */
   42.64 +class T0x05<T> {
   42.65 +    void m0x05() {
   42.66 +        new ArrayList<@A @DA T>();
   42.67      }
   42.68  }
   42.69  
   42.70 -/** method parameter generic/array */
   42.71 -class T0x0D {
   42.72 -    void m0x0D(HashMap<@A @DA Object, List<@A @DA List<@A @DA Class>>> s1) {}
   42.73 -}
   42.74 -
   42.75  /** method receiver */
   42.76  class T0x06 {
   42.77      void m0x06(@A @DA T0x06 this) {}
   42.78  }
   42.79  
   42.80 -/** method return type generic/array */
   42.81 -class T0x0B {
   42.82 -    Class<@A @DA Object> m0x0B() { return null; }
   42.83 -}
   42.84 -
   42.85 -/** field generic/array */
   42.86 -class T0x0F {
   42.87 -    HashMap<@A @DA Object, @A @DA Object> c1;
   42.88 -}
   42.89 -
   42.90 -/** method type parameter */
   42.91 -class T0x20<T, U> {
   42.92 -    <@A @DA T, @A @DA U> void m0x20() {}
   42.93 -}
   42.94 -
   42.95 -/** class type parameter */
   42.96 -class T0x22<@A @DA T, @A @DA U> {
   42.97 -}
   42.98 -
   42.99 -/** class type parameter bound */
  42.100 -class T0x10<T extends @A @DA Cloneable> {
  42.101 -}
  42.102 -
  42.103 -class T0x10A<T extends @A @DA Object> {
  42.104 -}
  42.105 -
  42.106 -/** method type parameter bound */
  42.107 -class T0x12<T> {
  42.108 -    <T extends @A @DA Cloneable> void m0x12() {}
  42.109 -}
  42.110 -
  42.111 -/** class type parameter bound generic/array */
  42.112 -class T0x11<T extends List<@A @DA T>> {
  42.113 -}
  42.114 -
  42.115 -/** method type parameter bound generic/array */
  42.116 -class T0x13 {
  42.117 -    static <T extends Comparable<@A @DA T>> T m0x13() {
  42.118 -        return null;
  42.119 -    }
  42.120 -}
  42.121 -
  42.122 -/** class extends/implements generic/array */
  42.123 -class T0x15<T> extends ArrayList<@A @DA T> {
  42.124 -}
  42.125 -
  42.126 -/** type test (instanceof) generic/array */
  42.127 -class T0x03<T> {
  42.128 -    void m0x03(T typeObj, Object obj) {
  42.129 -        boolean ok = obj instanceof String @A @DA [];
  42.130 -    }
  42.131 -}
  42.132 -
  42.133 -/** object creation (new) generic/array */
  42.134 -class T0x05<T> {
  42.135 -    void m0x05() {
  42.136 -        new ArrayList<@A @DA T>();
  42.137 +/** local variable */
  42.138 +class T0x08 {
  42.139 +    void m0x08() {
  42.140 +      @A @DA String s = null;
  42.141      }
  42.142  }
  42.143  
  42.144 @@ -171,20 +115,55 @@
  42.145      }
  42.146  }
  42.147  
  42.148 -/** type argument in constructor call generic/array */
  42.149 -class T0x19 {
  42.150 -    <T> T0x19() {}
  42.151 +/** method return type generic/array */
  42.152 +class T0x0B {
  42.153 +    Class<@A @DA Object> m0x0B() { return null; }
  42.154 +}
  42.155  
  42.156 -    void g() {
  42.157 -       new <List<@A @DA String>> T0x19();
  42.158 +/** method parameter generic/array */
  42.159 +class T0x0D {
  42.160 +    void m0x0D(HashMap<@A @DA Object, List<@A @DA List<@A @DA Class>>> s1) {}
  42.161 +}
  42.162 +
  42.163 +/** field generic/array */
  42.164 +class T0x0F {
  42.165 +    HashMap<@A @DA Object, @A @DA Object> c1;
  42.166 +}
  42.167 +
  42.168 +/** class type parameter bound */
  42.169 +class T0x10<T extends @A @DA Cloneable> {
  42.170 +}
  42.171 +
  42.172 +class T0x10A<T extends @A @DA Object> {
  42.173 +}
  42.174 +
  42.175 +/** class type parameter bound generic/array */
  42.176 +class T0x11<T extends List<@A @DA T>> {
  42.177 +}
  42.178 +
  42.179 +/** method type parameter bound */
  42.180 +class T0x12<T> {
  42.181 +    <T extends @A @DA Cloneable> void m0x12() {}
  42.182 +}
  42.183 +
  42.184 +/** method type parameter bound generic/array */
  42.185 +class T0x13 {
  42.186 +    static <T extends Comparable<@A @DA T>> T m0x13() {
  42.187 +        return null;
  42.188      }
  42.189  }
  42.190  
  42.191 -/** type argument in method call generic/array */
  42.192 -class T0x1B<T> {
  42.193 -    void m0x1B() {
  42.194 -        Collections.<T @A @DA []>emptyList();
  42.195 -    }
  42.196 +/** class extends/implements */
  42.197 +class T0x14 extends @A @DA Thread implements @A @DA Serializable, @A @DA Cloneable {
  42.198 +}
  42.199 +
  42.200 +/** class extends/implements generic/array */
  42.201 +class T0x15<T> extends ArrayList<@A @DA T> {
  42.202 +}
  42.203 +
  42.204 +/** exception type in throws */
  42.205 +class T0x16 {
  42.206 +    void m0x16() throws @A @DA Exception {}
  42.207  }
  42.208  
  42.209  /** type argument in constructor call */
  42.210 @@ -196,6 +175,15 @@
  42.211      }
  42.212  }
  42.213  
  42.214 +/** type argument in constructor call generic/array */
  42.215 +class T0x19 {
  42.216 +    <T> T0x19() {}
  42.217 +
  42.218 +    void g() {
  42.219 +       new <List<@A @DA String>> T0x19();
  42.220 +    }
  42.221 +}
  42.222 +
  42.223  /** type argument in method call */
  42.224  class T0x1A<T,U> {
  42.225      public static <T, U> T m() { return null; }
  42.226 @@ -204,11 +192,43 @@
  42.227      }
  42.228  }
  42.229  
  42.230 -/** class extends/implements */
  42.231 -class T0x14 extends @A @DA Thread implements @A @DA Serializable, @A @DA Cloneable {
  42.232 +/** type argument in method call generic/array */
  42.233 +class T0x1B<T> {
  42.234 +    void m0x1B() {
  42.235 +        Collections.<T @A @DA []>emptyList();
  42.236 +    }
  42.237  }
  42.238  
  42.239 -/** exception type in throws */
  42.240 -class T0x16 {
  42.241 -    void m0x16() throws @A @DA Exception {}
  42.242 +/** wildcard bound */
  42.243 +class T0x1C {
  42.244 +    void m0x1C(List<? extends @A @DA String> lst) {}
  42.245  }
  42.246 +
  42.247 +/** wildcard bound generic/array */
  42.248 +class T0x1D<T> {
  42.249 +    void m0x1D(List<? extends @A @DA List<int[]>> lst) {}
  42.250 +}
  42.251 +
  42.252 +/** method type parameter */
  42.253 +class T0x20 {
  42.254 +    <@A @DA T> void m0x20() {}
  42.255 +}
  42.256 +
  42.257 +class T0x20A {
  42.258 +    <@A @DTPA T> void m0x20A() {}
  42.259 +}
  42.260 +
  42.261 +class T0x20B {
  42.262 +    <T> void m0x20B(@A @DA T p) {}
  42.263 +}
  42.264 +
  42.265 +/** class type parameter */
  42.266 +class T0x22<@A @DA T> {
  42.267 +}
  42.268 +
  42.269 +class T0x22A<@A @DTPA T> {
  42.270 +}
  42.271 +
  42.272 +class T0x22B<T> {
  42.273 +    @A @DA T f;
  42.274 +}