Mercurial > jdk8-mips64-public > langtools / changeset

     1.1 --- a/src/share/bin/launcher.sh-template	Fri Jun 26 10:26:27 2009 -0700
     1.2 +++ b/src/share/bin/launcher.sh-template	Sun Jun 28 00:01:09 2009 -0700
     1.3 @@ -1,7 +1,7 @@
     1.4  #!/bin/sh
     1.5  
     1.6  #
     1.7 -# Copyright 2006-2007 Sun Microsystems, Inc.  All Rights Reserved.
     1.8 +# Copyright 2006-2009 Sun Microsystems, Inc.  All Rights Reserved.
     1.9  # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    1.10  #
    1.11  # This code is free software; you can redistribute it and/or modify it
    1.12 @@ -44,7 +44,27 @@
    1.13     bcp="$mylib/#PROGRAM#.jar":$cp 
    1.14  fi
    1.15  
    1.16 -# javac currently assumes that assertions are enabled in the launcher
    1.17 +# tools currently assumes that assertions are enabled in the launcher
    1.18  ea=-ea:com.sun.tools
    1.19  
    1.20 -"#TARGET_JAVA#" ${bcp:+-Xbootclasspath/p:"$bcp"} ${ea} -jar "${mydir}"/../lib/#PROGRAM#.jar "$@"
    1.21 +# Any parameters starting with -J are passed to the JVM.
    1.22 +# All other parameters become parameters of #PROGRAM#.
    1.23 +
    1.24 +# Separate out -J* options for the JVM
    1.25 +# Note jdk as possible default to run jtreg
    1.26 +# Unset IFS and use newline as arg separator to preserve spaces in args
    1.27 +DUALCASE=1  # for MKS: make case statement case-sensitive (6709498)
    1.28 +saveIFS="$IFS"
    1.29 +nl='
    1.30 +'
    1.31 +for i in "$@" ; do
    1.32 +   IFS=
    1.33 +   case $i in
    1.34 +   -J* )       javaOpts=$javaOpts$nl`echo $i | sed -e 's/^-J//'` ;;
    1.35 +   *   )       toolOpts=$toolOpts$nl$i ;;
    1.36 +   esac
    1.37 +   IFS="$saveIFS"
    1.38 +done
    1.39 +unset DUALCASE
    1.40 +
    1.41 +eval "#TARGET_JAVA#" "${bcp:+-Xbootclasspath/p:"$bcp"}" ${ea} ${javaOpts} -jar "${mydir}"/../lib/#PROGRAM#.jar ${toolOpts}

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/src/share/classes/com/sun/source/tree/AnnotatedTypeTree.java	Sun Jun 28 00:01:09 2009 -0700
     2.3 @@ -0,0 +1,47 @@
     2.4 +/*
     2.5 + * Copyright 2008-2009 Sun Microsystems, Inc.  All Rights Reserved.
     2.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     2.7 + *
     2.8 + * This code is free software; you can redistribute it and/or modify it
     2.9 + * under the terms of the GNU General Public License version 2 only, as
    2.10 + * published by the Free Software Foundation.  Sun designates this
    2.11 + * particular file as subject to the "Classpath" exception as provided
    2.12 + * by Sun in the LICENSE file that accompanied this code.
    2.13 + *
    2.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    2.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    2.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    2.17 + * version 2 for more details (a copy is included in the LICENSE file that
    2.18 + * accompanied this code).
    2.19 + *
    2.20 + * You should have received a copy of the GNU General Public License version
    2.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    2.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    2.23 + *
    2.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    2.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    2.26 + * have any questions.
    2.27 + */
    2.28 +
    2.29 +package com.sun.source.tree;
    2.30 +
    2.31 +import java.util.List;
    2.32 +
    2.33 +/**
    2.34 + * A tree node for an annotated type
    2.35 + *
    2.36 + * For example:
    2.37 + * <pre>
    2.38 + *    {@code @}<em>annotationType String</em>
    2.39 + *    {@code @}<em>annotationType</em> ( <em>arguments</em> ) <em>Date</em>
    2.40 + * </pre>
    2.41 + *
    2.42 + * @see "JSR 308: Annotations on Java Types"
    2.43 + *
    2.44 + * @author Mahmood Ali
    2.45 + * @since 1.7
    2.46 + */
    2.47 +public interface AnnotatedTypeTree extends ExpressionTree {
    2.48 +    List<? extends AnnotationTree> getAnnotations();
    2.49 +    ExpressionTree getUnderlyingType();
    2.50 +}

     3.1 --- a/src/share/classes/com/sun/source/tree/MethodTree.java	Fri Jun 26 10:26:27 2009 -0700
     3.2 +++ b/src/share/classes/com/sun/source/tree/MethodTree.java	Sun Jun 28 00:01:09 2009 -0700
     3.3 @@ -53,6 +53,7 @@
     3.4      Tree getReturnType();
     3.5      List<? extends TypeParameterTree> getTypeParameters();
     3.6      List<? extends VariableTree> getParameters();
     3.7 +    List<? extends AnnotationTree> getReceiverAnnotations();
     3.8      List<? extends ExpressionTree> getThrows();
     3.9      BlockTree getBody();
    3.10      Tree getDefaultValue(); // for annotation types

     4.1 --- a/src/share/classes/com/sun/source/tree/Tree.java	Fri Jun 26 10:26:27 2009 -0700
     4.2 +++ b/src/share/classes/com/sun/source/tree/Tree.java	Sun Jun 28 00:01:09 2009 -0700
     4.3 @@ -45,6 +45,9 @@
     4.4       * Enumerates all kinds of trees.
     4.5       */
     4.6      public enum Kind {
     4.7 +
     4.8 +        ANNOTATED_TYPE(AnnotatedTypeTree.class),
     4.9 +
    4.10          /**
    4.11           * Used for instances of {@link AnnotationTree}.
    4.12           */

     5.1 --- a/src/share/classes/com/sun/source/tree/TreeVisitor.java	Fri Jun 26 10:26:27 2009 -0700
     5.2 +++ b/src/share/classes/com/sun/source/tree/TreeVisitor.java	Sun Jun 28 00:01:09 2009 -0700
     5.3 @@ -57,6 +57,7 @@
     5.4   * @since 1.6
     5.5   */
     5.6  public interface TreeVisitor<R,P> {
     5.7 +    R visitAnnotatedType(AnnotatedTypeTree node, P p);
     5.8      R visitAnnotation(AnnotationTree node, P p);
     5.9      R visitMethodInvocation(MethodInvocationTree node, P p);
    5.10      R visitAssert(AssertTree node, P p);

     6.1 --- a/src/share/classes/com/sun/source/tree/TypeParameterTree.java	Fri Jun 26 10:26:27 2009 -0700
     6.2 +++ b/src/share/classes/com/sun/source/tree/TypeParameterTree.java	Sun Jun 28 00:01:09 2009 -0700
     6.3 @@ -47,4 +47,5 @@
     6.4  public interface TypeParameterTree extends Tree {
     6.5      Name getName();
     6.6      List<? extends Tree> getBounds();
     6.7 +    List<? extends AnnotationTree> getAnnotations();
     6.8  }

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/src/share/classes/com/sun/source/util/AbstractTypeProcessor.java	Sun Jun 28 00:01:09 2009 -0700
     7.3 @@ -0,0 +1,245 @@
     7.4 +/*
     7.5 + * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
     7.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     7.7 + *
     7.8 + * This code is free software; you can redistribute it and/or modify it
     7.9 + * under the terms of the GNU General Public License version 2 only, as
    7.10 + * published by the Free Software Foundation.  Sun designates this
    7.11 + * particular file as subject to the "Classpath" exception as provided
    7.12 + * by Sun in the LICENSE file that accompanied this code.
    7.13 + *
    7.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
    7.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    7.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    7.17 + * version 2 for more details (a copy is included in the LICENSE file that
    7.18 + * accompanied this code).
    7.19 + *
    7.20 + * You should have received a copy of the GNU General Public License version
    7.21 + * 2 along with this work; if not, write to the Free Software Foundation,
    7.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    7.23 + *
    7.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
    7.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
    7.26 + * have any questions.
    7.27 + */
    7.28 +
    7.29 +package com.sun.source.util;
    7.30 +
    7.31 +import java.util.ArrayList;
    7.32 +import java.util.HashSet;
    7.33 +import java.util.List;
    7.34 +import java.util.Set;
    7.35 +
    7.36 +import javax.annotation.processing.*;
    7.37 +import javax.lang.model.element.Name;
    7.38 +import javax.lang.model.element.TypeElement;
    7.39 +import javax.lang.model.util.ElementFilter;
    7.40 +
    7.41 +import com.sun.tools.javac.processing.JavacProcessingEnvironment;
    7.42 +import com.sun.tools.javac.util.Context;
    7.43 +import com.sun.tools.javac.util.Log;
    7.44 +
    7.45 +import com.sun.source.tree.ClassTree;
    7.46 +
    7.47 +/**
    7.48 + * This class is an abstract annotation processor designed to be a
    7.49 + * convenient superclass for concrete "type processors", processors that
    7.50 + * require the type information in the processed source.
    7.51 + *
    7.52 + * <p>Type processing occurs in one round after the tool (e.g. java compiler)
    7.53 + * analyzes the source (all sources taken as input to the tool and sources
    7.54 + * generated by other annotation processors).
    7.55 + *
    7.56 + * <p>The tool infrastructure will interact with classes extending this abstract
    7.57 + * class as follows:
    7.58 + *
    7.59 + * <ol>
    7.60 + * [1-3: Identical to {@link Processor} life cycle]
    7.61 + *
    7.62 + * <li>If an existing {@code Processor} object is not being used, to
    7.63 + * create an instance of a processor the tool calls the no-arg
    7.64 + * constructor of the processor class.
    7.65 + *
    7.66 + * <li>Next, the tool calls the {@link #init init} method with
    7.67 + * an appropriate {@code ProcessingEnvironment}.
    7.68 + *
    7.69 + * <li>Afterwards, the tool calls {@link #getSupportedAnnotationTypes
    7.70 + * getSupportedAnnotationTypes}, {@link #getSupportedOptions
    7.71 + * getSupportedOptions}, and {@link #getSupportedSourceVersion
    7.72 + * getSupportedSourceVersion}.  These methods are only called once per
    7.73 + * run, not on each round.
    7.74 + *
    7.75 + * [4-5Unique to {@code AbstractTypeProcessor} subclasses]
    7.76 + *
    7.77 + * <li>For each class containing a supported annotation, the tool calls
    7.78 + * {@link #typeProcess(TypeElement, TreePath) typeProcess} method on the
    7.79 + * {@code Processor}.  The class is guaranteed to be type-checked Java code
    7.80 + * and all the tree type and symbol information is resolved.
    7.81 + *
    7.82 + * <li>Finally, the tools calls the
    7.83 + * {@link #typeProcessingOver() typeProcessingOver} method
    7.84 + * on the {@code Processor}.
    7.85 + *
    7.86 + * </ol>
    7.87 + *
    7.88 + * <p>The tool is permitted to ask type processors to process a class once
    7.89 + * it is analyzed before the rest of classes are analyzed.  The tool is also
    7.90 + * permitted to stop type processing immediately if any errors are raised,
    7.91 + * without invoking {@code typeProcessingOver}
    7.92 + *
    7.93 + * <p>A subclass may override any of the methods in this class, as long as the
    7.94 + * general {@link javax.annotation.processing.Processor Processor}
    7.95 + * contract is obeyed, with one notable exception.
    7.96 + * {@link #process(Set, RoundEnvironment)} may not be overridden, as it
    7.97 + * is called during the regular annotation phase before classes are analyzed.
    7.98 + *
    7.99 + * @author Mahmood Ali
   7.100 + * @since 1.7
   7.101 + */
   7.102 +public abstract class AbstractTypeProcessor extends AbstractProcessor {
   7.103 +    private final Set<Name> elements = new HashSet<Name>();
   7.104 +    private boolean hasInvokedTypeProcessingOver = false;
   7.105 +    private JavacProcessingEnvironment env;
   7.106 +    private final AttributionTaskListener listener = new AttributionTaskListener();
   7.107 +
   7.108 +    /**
   7.109 +     * Constructor for subclasses to call.
   7.110 +     */
   7.111 +    protected AbstractTypeProcessor() { }
   7.112 +
   7.113 +    /**
   7.114 +     * {@inheritDoc}
   7.115 +     */
   7.116 +    @Override
   7.117 +    public void init(ProcessingEnvironment env) {
   7.118 +        super.init(env);
   7.119 +        this.env = (JavacProcessingEnvironment)env;
   7.120 +        prepareContext(this.env.getContext());
   7.121 +    }
   7.122 +
   7.123 +    /**
   7.124 +     * The use of this method is obsolete in type processors.  The method is
   7.125 +     * called during regular annotation processing phase only.
   7.126 +     */
   7.127 +    @Override
   7.128 +    public final boolean process(Set<? extends TypeElement> annotations,
   7.129 +            RoundEnvironment roundEnv) {
   7.130 +        for (TypeElement elem : ElementFilter.typesIn(roundEnv.getRootElements())) {
   7.131 +            elements.add(elem.getQualifiedName());
   7.132 +        }
   7.133 +        return false;
   7.134 +    }
   7.135 +
   7.136 +    /**
   7.137 +     * Processes a fully analyzed class that contains a supported annotation
   7.138 +     * (look {@link #getSupportedAnnotationTypes()}).
   7.139 +     *
   7.140 +     * <p>The passed class is always a valid type-checked Java code.
   7.141 +     *
   7.142 +     * @param element       element of the analyzed class
   7.143 +     * @param tree  the tree path to the element, with the leaf being a
   7.144 +     *              {@link ClassTree}
   7.145 +     */
   7.146 +    public abstract void typeProcess(TypeElement element, TreePath tree);
   7.147 +
   7.148 +    /**
   7.149 +     * A method to be called once all the classes are processed and no error
   7.150 +     * is reported.
   7.151 +     *
   7.152 +     * <p>Subclasses may override this method to do any aggregate analysis
   7.153 +     * (e.g. generate report, persistence) or resource deallocation.
   7.154 +     *
   7.155 +     * <p>If an error (a Java error or a processor error) is reported, this
   7.156 +     * method is not guaranteed to be invoked.
   7.157 +     */
   7.158 +    public void typeProcessingOver() { }
   7.159 +
   7.160 +    /**
   7.161 +     * adds a listener for attribution.
   7.162 +     */
   7.163 +    private void prepareContext(Context context) {
   7.164 +        TaskListener otherListener = context.get(TaskListener.class);
   7.165 +        if (otherListener == null) {
   7.166 +            context.put(TaskListener.class, listener);
   7.167 +        } else {
   7.168 +            // handle cases of multiple listeners
   7.169 +            context.put(TaskListener.class, (TaskListener)null);
   7.170 +            TaskListeners listeners = new TaskListeners();
   7.171 +            listeners.add(otherListener);
   7.172 +            listeners.add(listener);
   7.173 +            context.put(TaskListener.class, listeners);
   7.174 +        }
   7.175 +    }
   7.176 +
   7.177 +    /**
   7.178 +     * A task listener that invokes the processor whenever a class is fully
   7.179 +     * analyzed.
   7.180 +     */
   7.181 +    private final class AttributionTaskListener implements TaskListener {
   7.182 +
   7.183 +        @Override
   7.184 +        public void finished(TaskEvent e) {
   7.185 +            Log log = Log.instance(env.getContext());
   7.186 +
   7.187 +            if (!hasInvokedTypeProcessingOver && elements.isEmpty() && log.nerrors == 0) {
   7.188 +                typeProcessingOver();
   7.189 +                hasInvokedTypeProcessingOver = true;
   7.190 +            }
   7.191 +
   7.192 +            if (e.getKind() != TaskEvent.Kind.ANALYZE)
   7.193 +                return;
   7.194 +
   7.195 +            if (e.getTypeElement() == null)
   7.196 +                throw new AssertionError("event task without a type element");
   7.197 +            if (e.getCompilationUnit() == null)
   7.198 +                throw new AssertionError("even task without compilation unit");
   7.199 +
   7.200 +            if (!elements.remove(e.getTypeElement().getQualifiedName()))
   7.201 +                return;
   7.202 +
   7.203 +            if (log.nerrors != 0)
   7.204 +                return;
   7.205 +
   7.206 +            TypeElement elem = e.getTypeElement();
   7.207 +            TreePath p = Trees.instance(env).getPath(elem);
   7.208 +
   7.209 +            typeProcess(elem, p);
   7.210 +
   7.211 +            if (!hasInvokedTypeProcessingOver && elements.isEmpty() && log.nerrors == 0) {
   7.212 +                typeProcessingOver();
   7.213 +                hasInvokedTypeProcessingOver = true;
   7.214 +            }
   7.215 +        }
   7.216 +
   7.217 +        @Override
   7.218 +        public void started(TaskEvent e) { }
   7.219 +
   7.220 +    }
   7.221 +
   7.222 +    /**
   7.223 +     * A task listener multiplexer.
   7.224 +     */
   7.225 +    private static class TaskListeners implements TaskListener {
   7.226 +        private final List<TaskListener> listeners = new ArrayList<TaskListener>();
   7.227 +
   7.228 +        public void add(TaskListener listener) {
   7.229 +            listeners.add(listener);
   7.230 +        }
   7.231 +
   7.232 +        public void remove(TaskListener listener) {
   7.233 +            listeners.remove(listener);
   7.234 +        }
   7.235 +
   7.236 +        @Override
   7.237 +        public void finished(TaskEvent e) {
   7.238 +            for (TaskListener listener : listeners)
   7.239 +                listener.finished(e);
   7.240 +        }
   7.241 +
   7.242 +        @Override
   7.243 +        public void started(TaskEvent e) {
   7.244 +            for (TaskListener listener : listeners)
   7.245 +                listener.started(e);
   7.246 +        }
   7.247 +    }
   7.248 +}

     8.1 --- a/src/share/classes/com/sun/source/util/SimpleTreeVisitor.java	Fri Jun 26 10:26:27 2009 -0700
     8.2 +++ b/src/share/classes/com/sun/source/util/SimpleTreeVisitor.java	Sun Jun 28 00:01:09 2009 -0700
     8.3 @@ -244,6 +244,10 @@
     8.4          return defaultAction(node, p);
     8.5      }
     8.6  
     8.7 +    public R visitAnnotatedType(AnnotatedTypeTree node, P p) {
     8.8 +        return defaultAction(node, p);
     8.9 +    }
    8.10 +
    8.11      public R visitErroneous(ErroneousTree node, P p) {
    8.12          return defaultAction(node, p);
    8.13      }

     9.1 --- a/src/share/classes/com/sun/source/util/TreePath.java	Fri Jun 26 10:26:27 2009 -0700
     9.2 +++ b/src/share/classes/com/sun/source/util/TreePath.java	Sun Jun 28 00:01:09 2009 -0700
     9.3 @@ -120,19 +120,20 @@
     9.4      public Iterator<Tree> iterator() {
     9.5          return new Iterator<Tree>() {
     9.6              public boolean hasNext() {
     9.7 -                return curr.parent != null;
     9.8 +                return next != null;
     9.9              }
    9.10  
    9.11              public Tree next() {
    9.12 -                curr = curr.parent;
    9.13 -                return curr.leaf;
    9.14 +                Tree t = next.leaf;
    9.15 +                next = next.parent;
    9.16 +                return t;
    9.17              }
    9.18  
    9.19              public void remove() {
    9.20                  throw new UnsupportedOperationException();
    9.21              }
    9.22  
    9.23 -            private TreePath curr;
    9.24 +            private TreePath next = TreePath.this;
    9.25          };
    9.26      }
    9.27  

    10.1 --- a/src/share/classes/com/sun/source/util/TreeScanner.java	Fri Jun 26 10:26:27 2009 -0700
    10.2 +++ b/src/share/classes/com/sun/source/util/TreeScanner.java	Sun Jun 28 00:01:09 2009 -0700
    10.3 @@ -138,6 +138,7 @@
    10.4          r = scanAndReduce(node.getReturnType(), p, r);
    10.5          r = scanAndReduce(node.getTypeParameters(), p, r);
    10.6          r = scanAndReduce(node.getParameters(), p, r);
    10.7 +        r = scanAndReduce(node.getReceiverAnnotations(), p, r);
    10.8          r = scanAndReduce(node.getThrows(), p, r);
    10.9          r = scanAndReduce(node.getBody(), p, r);
   10.10          return r;
   10.11 @@ -354,7 +355,9 @@
   10.12      }
   10.13  
   10.14      public R visitTypeParameter(TypeParameterTree node, P p) {
   10.15 -        return scan(node.getBounds(), p);
   10.16 +        R r = scan(node.getAnnotations(), p);
   10.17 +        r = scanAndReduce(node.getBounds(), p, r);
   10.18 +        return r;
   10.19      }
   10.20  
   10.21      public R visitWildcard(WildcardTree node, P p) {
   10.22 @@ -371,6 +374,12 @@
   10.23          return r;
   10.24      }
   10.25  
   10.26 +   public R visitAnnotatedType(AnnotatedTypeTree node, P p) {
   10.27 +       R r = scan(node.getAnnotations(), p);
   10.28 +       r = scanAndReduce(node.getUnderlyingType(), p, r);
   10.29 +       return r;
   10.30 +   }
   10.31 +
   10.32      public R visitOther(Tree node, P p) {
   10.33          return null;
   10.34      }

    11.1 --- a/src/share/classes/com/sun/source/util/Trees.java	Fri Jun 26 10:26:27 2009 -0700
    11.2 +++ b/src/share/classes/com/sun/source/util/Trees.java	Sun Jun 28 00:01:09 2009 -0700
    11.3 @@ -35,6 +35,7 @@
    11.4  import javax.lang.model.type.DeclaredType;
    11.5  import javax.lang.model.type.ErrorType;
    11.6  import javax.lang.model.type.TypeMirror;
    11.7 +import javax.tools.Diagnostic;
    11.8  import javax.tools.JavaCompiler.CompilationTask;
    11.9  
   11.10  import com.sun.source.tree.ClassTree;
   11.11 @@ -182,7 +183,20 @@
   11.12      /**
   11.13        * Gets the original type from the ErrorType object.
   11.14        * @param errorType The errorType for which we want to get the original type.
   11.15 -      * @returns javax.lang.model.type.TypeMirror corresponding to the original type, replaced by the ErrorType.
   11.16 +      * @return javax.lang.model.type.TypeMirror corresponding to the original type, replaced by the ErrorType.
   11.17        */
   11.18      public abstract TypeMirror getOriginalType(ErrorType errorType);
   11.19 +
   11.20 +    /**
   11.21 +     * Prints a message of the specified kind at the location of the
   11.22 +     * tree within the provided compilation unit
   11.23 +     *
   11.24 +     * @param kind the kind of message
   11.25 +     * @param msg  the message, or an empty string if none
   11.26 +     * @param t    the tree to use as a position hint
   11.27 +     * @param root the compilation unit that contains tree
   11.28 +     */
   11.29 +    public abstract void printMessage(Diagnostic.Kind kind, CharSequence msg,
   11.30 +            com.sun.source.tree.Tree t,
   11.31 +            com.sun.source.tree.CompilationUnitTree root);
   11.32  }

    12.1 --- a/src/share/classes/com/sun/tools/classfile/Attribute.java	Fri Jun 26 10:26:27 2009 -0700
    12.2 +++ b/src/share/classes/com/sun/tools/classfile/Attribute.java	Sun Jun 28 00:01:09 2009 -0700
    12.3 @@ -54,6 +54,8 @@
    12.4      public static final String RuntimeInvisibleAnnotations = "RuntimeInvisibleAnnotations";
    12.5      public static final String RuntimeVisibleParameterAnnotations = "RuntimeVisibleParameterAnnotations";
    12.6      public static final String RuntimeInvisibleParameterAnnotations = "RuntimeInvisibleParameterAnnotations";
    12.7 +    public static final String RuntimeVisibleTypeAnnotations = "RuntimeVisibleTypeAnnotations";
    12.8 +    public static final String RuntimeInvisibleTypeAnnotations = "RuntimeInvisibleTypeAnnotations";
    12.9      public static final String Signature                = "Signature";
   12.10      public static final String SourceDebugExtension     = "SourceDebugExtension";
   12.11      public static final String SourceFile               = "SourceFile";
   12.12 @@ -131,6 +133,8 @@
   12.13                  standardAttributes.put(RuntimeInvisibleParameterAnnotations, RuntimeInvisibleParameterAnnotations_attribute.class);
   12.14                  standardAttributes.put(RuntimeVisibleAnnotations, RuntimeVisibleAnnotations_attribute.class);
   12.15                  standardAttributes.put(RuntimeVisibleParameterAnnotations, RuntimeVisibleParameterAnnotations_attribute.class);
   12.16 +                standardAttributes.put(RuntimeVisibleTypeAnnotations, RuntimeVisibleTypeAnnotations_attribute.class);
   12.17 +                standardAttributes.put(RuntimeInvisibleTypeAnnotations, RuntimeInvisibleTypeAnnotations_attribute.class);
   12.18                  standardAttributes.put(Signature,     Signature_attribute.class);
   12.19                  standardAttributes.put(SourceID, SourceID_attribute.class);
   12.20              }
   12.21 @@ -184,6 +188,8 @@
   12.22          R visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, P p);
   12.23          R visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, P p);
   12.24          R visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, P p);
   12.25 +        R visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, P p);
   12.26 +        R visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, P p);
   12.27          R visitSignature(Signature_attribute attr, P p);
   12.28          R visitSourceDebugExtension(SourceDebugExtension_attribute attr, P p);
   12.29          R visitSourceFile(SourceFile_attribute attr, P p);

    13.1 --- a/src/share/classes/com/sun/tools/classfile/ClassWriter.java	Fri Jun 26 10:26:27 2009 -0700
    13.2 +++ b/src/share/classes/com/sun/tools/classfile/ClassWriter.java	Sun Jun 28 00:01:09 2009 -0700
    13.3 @@ -1,3 +1,4 @@
    13.4 +
    13.5  /*
    13.6   * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
    13.7   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    13.8 @@ -477,6 +478,16 @@
    13.9              return null;
   13.10          }
   13.11  
   13.12 +        public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
   13.13 +            annotationWriter.write(attr.annotations, out);
   13.14 +            return null;
   13.15 +        }
   13.16 +
   13.17 +        public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
   13.18 +            annotationWriter.write(attr.annotations, out);
   13.19 +            return null;
   13.20 +        }
   13.21 +
   13.22          public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
   13.23              out.writeByte(attr.parameter_annotations.length);
   13.24              for (Annotation[] annos: attr.parameter_annotations)
   13.25 @@ -636,6 +647,12 @@
   13.26                  write(anno, out);
   13.27          }
   13.28  
   13.29 +        public void write(ExtendedAnnotation[] annos, ClassOutputStream out) {
   13.30 +            out.writeShort(annos.length);
   13.31 +            for (ExtendedAnnotation anno: annos)
   13.32 +                write(anno, out);
   13.33 +        }
   13.34 +
   13.35          public void write(Annotation anno, ClassOutputStream out) {
   13.36              out.writeShort(anno.type_index);
   13.37              out.writeShort(anno.element_value_pairs.length);
   13.38 @@ -643,6 +660,11 @@
   13.39                  write(p, out);
   13.40          }
   13.41  
   13.42 +        public void write(ExtendedAnnotation anno, ClassOutputStream out) {
   13.43 +            write(anno.annotation, out);
   13.44 +            write(anno.position, out);
   13.45 +        }
   13.46 +
   13.47          public void write(element_value_pair pair, ClassOutputStream out) {
   13.48              out.writeShort(pair.element_name_index);
   13.49              write(pair.value, out);
   13.50 @@ -680,5 +702,95 @@
   13.51                  write(v, out);
   13.52              return null;
   13.53          }
   13.54 +
   13.55 +        private void write(ExtendedAnnotation.Position p, ClassOutputStream out) {
   13.56 +            out.writeByte(p.type.targetTypeValue());
   13.57 +            switch (p.type) {
   13.58 +            // type case
   13.59 +            case TYPECAST:
   13.60 +            case TYPECAST_GENERIC_OR_ARRAY:
   13.61 +            // object creation
   13.62 +            case INSTANCEOF:
   13.63 +            case INSTANCEOF_GENERIC_OR_ARRAY:
   13.64 +            // new expression
   13.65 +            case NEW:
   13.66 +            case NEW_GENERIC_OR_ARRAY:
   13.67 +            case NEW_TYPE_ARGUMENT:
   13.68 +            case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
   13.69 +                out.writeShort(p.offset);
   13.70 +                break;
   13.71 +             // local variable
   13.72 +            case LOCAL_VARIABLE:
   13.73 +            case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
   13.74 +                int table_length = p.lvarOffset.length;
   13.75 +                out.writeShort(table_length);
   13.76 +                for (int i = 0; i < table_length; ++i) {
   13.77 +                    out.writeShort(1);  // for table length
   13.78 +                    out.writeShort(p.lvarOffset[i]);
   13.79 +                    out.writeShort(p.lvarLength[i]);
   13.80 +                    out.writeShort(p.lvarIndex[i]);
   13.81 +                }
   13.82 +                break;
   13.83 +             // method receiver
   13.84 +            case METHOD_RECEIVER:
   13.85 +                // Do nothing
   13.86 +                break;
   13.87 +            // type parameters
   13.88 +            case CLASS_TYPE_PARAMETER:
   13.89 +            case METHOD_TYPE_PARAMETER:
   13.90 +                out.writeByte(p.parameter_index);
   13.91 +                break;
   13.92 +            // type parameters bounds
   13.93 +            case CLASS_TYPE_PARAMETER_BOUND:
   13.94 +            case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
   13.95 +            case METHOD_TYPE_PARAMETER_BOUND:
   13.96 +            case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
   13.97 +                out.writeByte(p.parameter_index);
   13.98 +                out.writeByte(p.bound_index);
   13.99 +                break;
  13.100 +             // wildcards
  13.101 +            case WILDCARD_BOUND:
  13.102 +            case WILDCARD_BOUND_GENERIC_OR_ARRAY:
  13.103 +                write(p.wildcard_position, out);
  13.104 +                break;
  13.105 +            // Class extends and implements clauses
  13.106 +            case CLASS_EXTENDS:
  13.107 +            case CLASS_EXTENDS_GENERIC_OR_ARRAY:
  13.108 +                out.writeByte(p.type_index);
  13.109 +                break;
  13.110 +            // throws
  13.111 +            case THROWS:
  13.112 +                out.writeByte(p.type_index);
  13.113 +                break;
  13.114 +            case CLASS_LITERAL:
  13.115 +                out.writeShort(p.offset);
  13.116 +                break;
  13.117 +            // method parameter: not specified
  13.118 +            case METHOD_PARAMETER_GENERIC_OR_ARRAY:
  13.119 +                out.writeByte(p.parameter_index);
  13.120 +                break;
  13.121 +            // method type argument: wasn't specified
  13.122 +            case METHOD_TYPE_ARGUMENT:
  13.123 +            case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  13.124 +                out.writeShort(p.offset);
  13.125 +                out.writeByte(p.type_index);
  13.126 +                break;
  13.127 +            // We don't need to worry abut these
  13.128 +            case METHOD_RETURN_GENERIC_OR_ARRAY:
  13.129 +            case FIELD_GENERIC_OR_ARRAY:
  13.130 +                break;
  13.131 +            case UNKNOWN:
  13.132 +                break;
  13.133 +            default:
  13.134 +                throw new AssertionError("unknown type: " + p);
  13.135 +            }
  13.136 +
  13.137 +            // Append location data for generics/arrays.
  13.138 +            if (p.type.hasLocation()) {
  13.139 +                out.writeShort(p.location.size());
  13.140 +                for (int i : p.location)
  13.141 +                    out.writeByte((byte)i);
  13.142 +            }
  13.143 +        }
  13.144      }
  13.145  }

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/src/share/classes/com/sun/tools/classfile/ExtendedAnnotation.java	Sun Jun 28 00:01:09 2009 -0700
    14.3 @@ -0,0 +1,614 @@
    14.4 +/*
    14.5 + * Copyright 2009 Sun Microsystems, Inc.  All Rights Reserved.
    14.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    14.7 + *
    14.8 + * This code is free software; you can redistribute it and/or modify it
    14.9 + * under the terms of the GNU General Public License version 2 only, as
   14.10 + * published by the Free Software Foundation.  Sun designates this
   14.11 + * particular file as subject to the "Classpath" exception as provided
   14.12 + * by Sun in the LICENSE file that accompanied this code.
   14.13 + *
   14.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   14.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14.17 + * version 2 for more details (a copy is included in the LICENSE file that
   14.18 + * accompanied this code).
   14.19 + *
   14.20 + * You should have received a copy of the GNU General Public License version
   14.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   14.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   14.23 + *
   14.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   14.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   14.26 + * have any questions.
   14.27 + */
   14.28 +
   14.29 +package com.sun.tools.classfile;
   14.30 +
   14.31 +import java.io.IOException;
   14.32 +import java.util.ArrayList;
   14.33 +import java.util.EnumSet;
   14.34 +import java.util.List;
   14.35 +import java.util.Set;
   14.36 +
   14.37 +import static com.sun.tools.classfile.ExtendedAnnotation.TargetAttribute.*;
   14.38 +
   14.39 +/**
   14.40 + * See JSR 308 specification, section 4.1
   14.41 + *
   14.42 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   14.43 + *  you write code that depends on this, you do so at your own risk.
   14.44 + *  This code and its internal interfaces are subject to change or
   14.45 + *  deletion without notice.</b>
   14.46 + */
   14.47 +public class ExtendedAnnotation {
   14.48 +    ExtendedAnnotation(ClassReader cr) throws IOException, Annotation.InvalidAnnotation {
   14.49 +        annotation = new Annotation(cr);
   14.50 +        position = read_position(cr);
   14.51 +    }
   14.52 +
   14.53 +    public ExtendedAnnotation(ConstantPool constant_pool,
   14.54 +            Annotation annotation, Position position) {
   14.55 +        this.annotation = annotation;
   14.56 +        this.position = position;
   14.57 +    }
   14.58 +
   14.59 +    public int length() {
   14.60 +        int n = annotation.length();
   14.61 +        n += position_length(position);
   14.62 +        return n;
   14.63 +    }
   14.64 +
   14.65 +    public final Annotation annotation;
   14.66 +    public final Position position;
   14.67 +
   14.68 +    private static Position read_position(ClassReader cr) throws IOException, Annotation.InvalidAnnotation {
   14.69 +        // Copied from ClassReader
   14.70 +        int tag = (byte)cr.readUnsignedByte();  // cast to introduce signedness
   14.71 +        if (!TargetType.isValidTargetTypeValue(tag))
   14.72 +            throw new Annotation.InvalidAnnotation("invalid type annotation target type value: " + tag);
   14.73 +
   14.74 +        TargetType type = TargetType.fromTargetTypeValue(tag);
   14.75 +
   14.76 +        Position position = new Position();
   14.77 +        position.type = type;
   14.78 +
   14.79 +        switch (type) {
   14.80 +        // type case
   14.81 +        case TYPECAST:
   14.82 +        case TYPECAST_GENERIC_OR_ARRAY:
   14.83 +        // object creation
   14.84 +        case INSTANCEOF:
   14.85 +        case INSTANCEOF_GENERIC_OR_ARRAY:
   14.86 +        // new expression
   14.87 +        case NEW:
   14.88 +        case NEW_GENERIC_OR_ARRAY:
   14.89 +            position.offset = cr.readUnsignedShort();
   14.90 +            break;
   14.91 +         // local variable
   14.92 +        case LOCAL_VARIABLE:
   14.93 +        case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
   14.94 +            int table_length = cr.readUnsignedShort();
   14.95 +            position.lvarOffset = new int[table_length];
   14.96 +            position.lvarLength = new int[table_length];
   14.97 +            position.lvarIndex = new int[table_length];
   14.98 +            for (int i = 0; i < table_length; ++i) {
   14.99 +                position.lvarOffset[i] = cr.readUnsignedShort();
  14.100 +                position.lvarLength[i] = cr.readUnsignedShort();
  14.101 +                position.lvarIndex[i] = cr.readUnsignedShort();
  14.102 +            }
  14.103 +            break;
  14.104 +         // method receiver
  14.105 +        case METHOD_RECEIVER:
  14.106 +            // Do nothing
  14.107 +            break;
  14.108 +        // type parameters
  14.109 +        case CLASS_TYPE_PARAMETER:
  14.110 +        case METHOD_TYPE_PARAMETER:
  14.111 +            position.parameter_index = cr.readUnsignedByte();
  14.112 +            break;
  14.113 +        // type parameter bounds
  14.114 +        case CLASS_TYPE_PARAMETER_BOUND:
  14.115 +        case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  14.116 +        case METHOD_TYPE_PARAMETER_BOUND:
  14.117 +        case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  14.118 +            position.parameter_index = cr.readUnsignedByte();
  14.119 +            position.bound_index = cr.readUnsignedByte();
  14.120 +            break;
  14.121 +         // wildcards
  14.122 +        case WILDCARD_BOUND:
  14.123 +        case WILDCARD_BOUND_GENERIC_OR_ARRAY:
  14.124 +            position.wildcard_position = read_position(cr);
  14.125 +            break;
  14.126 +         // Class extends and implements clauses
  14.127 +        case CLASS_EXTENDS:
  14.128 +        case CLASS_EXTENDS_GENERIC_OR_ARRAY:
  14.129 +            position.type_index = cr.readUnsignedByte();
  14.130 +            break;
  14.131 +        // throws
  14.132 +        case THROWS:
  14.133 +            position.type_index = cr.readUnsignedByte();
  14.134 +            break;
  14.135 +        case CLASS_LITERAL:
  14.136 +        case CLASS_LITERAL_GENERIC_OR_ARRAY:
  14.137 +            position.offset = cr.readUnsignedShort();
  14.138 +            break;
  14.139 +        // method parameter: not specified
  14.140 +        case METHOD_PARAMETER_GENERIC_OR_ARRAY:
  14.141 +            position.parameter_index = cr.readUnsignedByte();
  14.142 +            break;
  14.143 +        // method type argument: wasn't specified
  14.144 +        case NEW_TYPE_ARGUMENT:
  14.145 +        case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  14.146 +        case METHOD_TYPE_ARGUMENT:
  14.147 +        case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  14.148 +            position.offset = cr.readUnsignedShort();
  14.149 +            position.type_index = cr.readUnsignedByte();
  14.150 +            break;
  14.151 +        // We don't need to worry abut these
  14.152 +        case METHOD_RETURN_GENERIC_OR_ARRAY:
  14.153 +        case FIELD_GENERIC_OR_ARRAY:
  14.154 +            break;
  14.155 +        case UNKNOWN:
  14.156 +            break;
  14.157 +        default:
  14.158 +            throw new AssertionError("Cannot be here");
  14.159 +        }
  14.160 +
  14.161 +        if (type.hasLocation()) {
  14.162 +            int len = cr.readUnsignedShort();
  14.163 +            List<Integer> loc = new ArrayList<Integer>(len);
  14.164 +            for (int i = 0; i < len; i++)
  14.165 +                loc.add(cr.readUnsignedByte());
  14.166 +            position.location = loc;
  14.167 +        }
  14.168 +        return position;
  14.169 +    }
  14.170 +
  14.171 +    private static int position_length(Position pos) {
  14.172 +        int n = 0;
  14.173 +        n += 1; // target_type
  14.174 +        switch (pos.type) {
  14.175 +        // type case
  14.176 +        case TYPECAST:
  14.177 +        case TYPECAST_GENERIC_OR_ARRAY:
  14.178 +        // object creation
  14.179 +        case INSTANCEOF:
  14.180 +        case INSTANCEOF_GENERIC_OR_ARRAY:
  14.181 +        // new expression
  14.182 +        case NEW:
  14.183 +        case NEW_GENERIC_OR_ARRAY:
  14.184 +            n += 2;
  14.185 +            break;
  14.186 +         // local variable
  14.187 +        case LOCAL_VARIABLE:
  14.188 +        case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
  14.189 +            n += 2; // table_length;
  14.190 +            int table_length = pos.lvarOffset.length;
  14.191 +            n += 2 * table_length; // offset
  14.192 +            n += 2 * table_length; // length;
  14.193 +            n += 2 * table_length; // index
  14.194 +            break;
  14.195 +         // method receiver
  14.196 +        case METHOD_RECEIVER:
  14.197 +            // Do nothing
  14.198 +            break;
  14.199 +        // type parameters
  14.200 +        case CLASS_TYPE_PARAMETER:
  14.201 +        case METHOD_TYPE_PARAMETER:
  14.202 +            n += 1; // parameter_index;
  14.203 +            break;
  14.204 +        // type parameter bounds
  14.205 +        case CLASS_TYPE_PARAMETER_BOUND:
  14.206 +        case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  14.207 +        case METHOD_TYPE_PARAMETER_BOUND:
  14.208 +        case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  14.209 +            n += 1; // parameter_index
  14.210 +            n += 1; // bound_index
  14.211 +            break;
  14.212 +        case WILDCARD_BOUND:
  14.213 +        case WILDCARD_BOUND_GENERIC_OR_ARRAY:
  14.214 +            n += position_length(pos.wildcard_position);
  14.215 +            break;
  14.216 +         // Class extends and implements clauses
  14.217 +        case CLASS_EXTENDS:
  14.218 +        case CLASS_EXTENDS_GENERIC_OR_ARRAY:
  14.219 +            n += 1; // type_index
  14.220 +            break;
  14.221 +        // throws
  14.222 +        case THROWS:
  14.223 +            n += 1; // type_index
  14.224 +            break;
  14.225 +        case CLASS_LITERAL:
  14.226 +        case CLASS_LITERAL_GENERIC_OR_ARRAY:
  14.227 +            n += 1; // offset
  14.228 +            break;
  14.229 +        // method parameter: not specified
  14.230 +        case METHOD_PARAMETER_GENERIC_OR_ARRAY:
  14.231 +            n += 1; // parameter_index
  14.232 +            break;
  14.233 +        // method type argument: wasn't specified
  14.234 +        case NEW_TYPE_ARGUMENT:
  14.235 +        case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  14.236 +        case METHOD_TYPE_ARGUMENT:
  14.237 +        case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  14.238 +            n += 2; // offset
  14.239 +            n += 1; // type index
  14.240 +            break;
  14.241 +        // We don't need to worry abut these
  14.242 +        case METHOD_RETURN_GENERIC_OR_ARRAY:
  14.243 +        case FIELD_GENERIC_OR_ARRAY:
  14.244 +            break;
  14.245 +        case UNKNOWN:
  14.246 +            break;
  14.247 +        default:
  14.248 +        }
  14.249 +
  14.250 +        if (pos.type.hasLocation()) {
  14.251 +            n += 2; // length
  14.252 +            n += 1 * pos.location.size(); // actual array size
  14.253 +        }
  14.254 +
  14.255 +        return n;
  14.256 +    }
  14.257 +
  14.258 +    // Code duplicated from com.sun.tools.javac.code.TypeAnnotations.Position
  14.259 +    public static class Position {
  14.260 +
  14.261 +        public TargetType type = TargetType.UNKNOWN;
  14.262 +
  14.263 +        // For generic/array types.
  14.264 +        public List<Integer> location = new ArrayList<Integer>();
  14.265 +
  14.266 +        // Tree position.
  14.267 +        public int pos = -1;
  14.268 +
  14.269 +        // For typecasts, type tests, new (and locals, as start_pc).
  14.270 +        public int offset = -1;
  14.271 +
  14.272 +        // For locals.
  14.273 +        public int[] lvarOffset = new int[] { -1 };
  14.274 +        public int[] lvarLength = new int[] { -1 };
  14.275 +        public int[] lvarIndex = new int[] { -1 };
  14.276 +
  14.277 +        // For type parameter bound
  14.278 +        public int bound_index = -1;
  14.279 +
  14.280 +        // For type parameter and method parameter
  14.281 +        public int parameter_index = -1;
  14.282 +
  14.283 +        // For class extends, implements, and throws classes
  14.284 +        public int type_index = -2;
  14.285 +
  14.286 +        // For wildcards
  14.287 +        public Position wildcard_position = null;
  14.288 +
  14.289 +        @Override
  14.290 +        public String toString() {
  14.291 +            StringBuilder sb = new StringBuilder();
  14.292 +            sb.append('[');
  14.293 +            sb.append(type);
  14.294 +
  14.295 +            switch (type) {
  14.296 +            // type case
  14.297 +            case TYPECAST:
  14.298 +            case TYPECAST_GENERIC_OR_ARRAY:
  14.299 +            // object creation
  14.300 +            case INSTANCEOF:
  14.301 +            case INSTANCEOF_GENERIC_OR_ARRAY:
  14.302 +            // new expression
  14.303 +            case NEW:
  14.304 +            case NEW_GENERIC_OR_ARRAY:
  14.305 +            case NEW_TYPE_ARGUMENT:
  14.306 +            case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  14.307 +                sb.append(", offset = ");
  14.308 +                sb.append(offset);
  14.309 +                break;
  14.310 +             // local variable
  14.311 +            case LOCAL_VARIABLE:
  14.312 +            case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
  14.313 +                sb.append(", {");
  14.314 +                for (int i = 0; i < lvarOffset.length; ++i) {
  14.315 +                    if (i != 0) sb.append("; ");
  14.316 +                    sb.append(", start_pc = ");
  14.317 +                    sb.append(lvarOffset[i]);
  14.318 +                    sb.append(", length = ");
  14.319 +                    sb.append(lvarLength[i]);
  14.320 +                    sb.append(", index = ");
  14.321 +                    sb.append(lvarIndex[i]);
  14.322 +                }
  14.323 +                sb.append("}");
  14.324 +                break;
  14.325 +             // method receiver
  14.326 +            case METHOD_RECEIVER:
  14.327 +                // Do nothing
  14.328 +                break;
  14.329 +            // type parameters
  14.330 +            case CLASS_TYPE_PARAMETER:
  14.331 +            case METHOD_TYPE_PARAMETER:
  14.332 +                sb.append(", param_index = ");
  14.333 +                sb.append(parameter_index);
  14.334 +                break;
  14.335 +            // type parameters bound
  14.336 +            case CLASS_TYPE_PARAMETER_BOUND:
  14.337 +            case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  14.338 +            case METHOD_TYPE_PARAMETER_BOUND:
  14.339 +            case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  14.340 +                sb.append(", param_index = ");
  14.341 +                sb.append(parameter_index);
  14.342 +                sb.append(", bound_index = ");
  14.343 +                sb.append(bound_index);
  14.344 +                break;
  14.345 +             // wildcard
  14.346 +            case WILDCARD_BOUND:
  14.347 +            case WILDCARD_BOUND_GENERIC_OR_ARRAY:
  14.348 +                sb.append(", wild_card = ");
  14.349 +                sb.append(wildcard_position);
  14.350 +                break;
  14.351 +             // Class extends and implements clauses
  14.352 +            case CLASS_EXTENDS:
  14.353 +            case CLASS_EXTENDS_GENERIC_OR_ARRAY:
  14.354 +                sb.append(", type_index = ");
  14.355 +                sb.append(type_index);
  14.356 +                break;
  14.357 +            // throws
  14.358 +            case THROWS:
  14.359 +                sb.append(", type_index = ");
  14.360 +                sb.append(type_index);
  14.361 +                break;
  14.362 +            case CLASS_LITERAL:
  14.363 +                sb.append(", offset = ");
  14.364 +                sb.append(offset);
  14.365 +                break;
  14.366 +            // method parameter: not specified
  14.367 +            case METHOD_PARAMETER_GENERIC_OR_ARRAY:
  14.368 +                sb.append(", param_index = ");
  14.369 +                sb.append(parameter_index);
  14.370 +                break;
  14.371 +            // method type argument: wasn't specified
  14.372 +            case METHOD_TYPE_ARGUMENT:
  14.373 +            case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  14.374 +                sb.append(", offset = ");
  14.375 +                sb.append(offset);
  14.376 +                sb.append(", type_index = ");
  14.377 +                sb.append(type_index);
  14.378 +                break;
  14.379 +            // We don't need to worry abut these
  14.380 +            case METHOD_RETURN_GENERIC_OR_ARRAY:
  14.381 +            case FIELD_GENERIC_OR_ARRAY:
  14.382 +                break;
  14.383 +            case UNKNOWN:
  14.384 +                break;
  14.385 +            default:
  14.386 +                throw new AssertionError("unknown type: " + type);
  14.387 +            }
  14.388 +
  14.389 +            // Append location data for generics/arrays.
  14.390 +            if (type.hasLocation()) {
  14.391 +                sb.append(", location = (");
  14.392 +                sb.append(location);
  14.393 +                sb.append(")");
  14.394 +            }
  14.395 +
  14.396 +            sb.append(", pos = ");
  14.397 +            sb.append(pos);
  14.398 +
  14.399 +            sb.append(']');
  14.400 +            return sb.toString();
  14.401 +        }
  14.402 +    }
  14.403 +
  14.404 +    // Code duplicated from com.sun.tools.javac.comp.TargetType
  14.405 +    public enum TargetType {
  14.406 +
  14.407 +        /** For annotations on typecasts. */
  14.408 +        TYPECAST(0x00),
  14.409 +
  14.410 +        /** For annotations on a type argument or nested array of a typecast. */
  14.411 +        TYPECAST_GENERIC_OR_ARRAY(0x01, HasLocation),
  14.412 +
  14.413 +        /** For annotations on type tests. */
  14.414 +        INSTANCEOF(0x02),
  14.415 +
  14.416 +        /** For annotations on a type argument or nested array of a type test. */
  14.417 +        INSTANCEOF_GENERIC_OR_ARRAY(0x03, HasLocation),
  14.418 +
  14.419 +        /** For annotations on object creation expressions. */
  14.420 +        NEW(0x04),
  14.421 +
  14.422 +        /**
  14.423 +         * For annotations on a type argument or nested array of an object creation
  14.424 +         * expression.
  14.425 +         */
  14.426 +        NEW_GENERIC_OR_ARRAY(0x05, HasLocation),
  14.427 +
  14.428 +
  14.429 +        /** For annotations on the method receiver. */
  14.430 +        METHOD_RECEIVER(0x06),
  14.431 +
  14.432 +        // invalid location
  14.433 +        // METHOD_RECEIVER_GENERIC_OR_ARRAY(0x07, HasLocation),
  14.434 +
  14.435 +        /** For annotations on local variables. */
  14.436 +        LOCAL_VARIABLE(0x08),
  14.437 +
  14.438 +        /** For annotations on a type argument or nested array of a local. */
  14.439 +        LOCAL_VARIABLE_GENERIC_OR_ARRAY(0x09, HasLocation),
  14.440 +
  14.441 +        // already handled by regular annotations
  14.442 +        // METHOD_RETURN(0x0A),
  14.443 +
  14.444 +        /**
  14.445 +         * For annotations on a type argument or nested array of a method return
  14.446 +         * type.
  14.447 +         */
  14.448 +        METHOD_RETURN_GENERIC_OR_ARRAY(0x0B, HasLocation),
  14.449 +
  14.450 +        // already handled by regular annotations
  14.451 +        // METHOD_PARAMETER(0x0C),
  14.452 +
  14.453 +        /** For annotations on a type argument or nested array of a method parameter. */
  14.454 +        METHOD_PARAMETER_GENERIC_OR_ARRAY(0x0D, HasLocation),
  14.455 +
  14.456 +        // already handled by regular annotations
  14.457 +        // FIELD(0x0E),
  14.458 +
  14.459 +        /** For annotations on a type argument or nested array of a field. */
  14.460 +        FIELD_GENERIC_OR_ARRAY(0x0F, HasLocation),
  14.461 +
  14.462 +        /** For annotations on a bound of a type parameter of a class. */
  14.463 +        CLASS_TYPE_PARAMETER_BOUND(0x10, HasBound, HasParameter),
  14.464 +
  14.465 +        /**
  14.466 +         * For annotations on a type argument or nested array of a bound of a type
  14.467 +         * parameter of a class.
  14.468 +         */
  14.469 +        CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY(0x11, HasBound, HasLocation, HasParameter),
  14.470 +
  14.471 +        /** For annotations on a bound of a type parameter of a method. */
  14.472 +        METHOD_TYPE_PARAMETER_BOUND(0x12, HasBound, HasParameter),
  14.473 +
  14.474 +        /**
  14.475 +         * For annotations on a type argument or nested array of a bound of a type
  14.476 +         * parameter of a method.
  14.477 +         */
  14.478 +        METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY(0x13, HasBound, HasLocation, HasParameter),
  14.479 +
  14.480 +        /** For annotations on the type of an "extends" or "implements" clause. */
  14.481 +        CLASS_EXTENDS(0x14),
  14.482 +
  14.483 +        /** For annotations on the inner type of an "extends" or "implements" clause. */
  14.484 +        CLASS_EXTENDS_GENERIC_OR_ARRAY(0x15, HasLocation),
  14.485 +
  14.486 +        /** For annotations on a throws clause in a method declaration. */
  14.487 +        THROWS(0x16),
  14.488 +
  14.489 +        // invalid location
  14.490 +        // THROWS_GENERIC_OR_ARRAY(0x17, HasLocation),
  14.491 +
  14.492 +        /** For annotations in type arguments of object creation expressions. */
  14.493 +        NEW_TYPE_ARGUMENT(0x18),
  14.494 +        NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY(0x19, HasLocation),
  14.495 +
  14.496 +        METHOD_TYPE_ARGUMENT(0x1A),
  14.497 +        METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY(0x1B, HasLocation),
  14.498 +
  14.499 +        WILDCARD_BOUND(0x1C, HasBound),
  14.500 +        WILDCARD_BOUND_GENERIC_OR_ARRAY(0x1D, HasBound, HasLocation),
  14.501 +
  14.502 +        CLASS_LITERAL(0x1E),
  14.503 +        CLASS_LITERAL_GENERIC_OR_ARRAY(0x1F, HasLocation),
  14.504 +
  14.505 +        METHOD_TYPE_PARAMETER(0x20, HasParameter),
  14.506 +
  14.507 +        // invalid location
  14.508 +        // METHOD_TYPE_PARAMETER_GENERIC_OR_ARRAY(0x21, HasLocation, HasParameter),
  14.509 +
  14.510 +        CLASS_TYPE_PARAMETER(0x22, HasParameter),
  14.511 +
  14.512 +        // invalid location
  14.513 +        // CLASS_TYPE_PARAMETER_GENERIC_OR_ARRAY(0x23, HasLocation, HasParameter),
  14.514 +
  14.515 +        /** For annotations with an unknown target. */
  14.516 +        UNKNOWN(-1);
  14.517 +
  14.518 +        static final int MAXIMUM_TARGET_TYPE_VALUE = 0x22;
  14.519 +
  14.520 +        private final int targetTypeValue;
  14.521 +        private Set<TargetAttribute> flags;
  14.522 +
  14.523 +        TargetType(int targetTypeValue, TargetAttribute... attrs) {
  14.524 +            if (targetTypeValue < Byte.MIN_VALUE
  14.525 +                || targetTypeValue > Byte.MAX_VALUE)
  14.526 +                throw new AssertionError("attribute type value needs to be a byte: " + targetTypeValue);
  14.527 +            this.targetTypeValue = (byte)targetTypeValue;
  14.528 +            this.flags = EnumSet.noneOf(TargetAttribute.class);
  14.529 +            for (TargetAttribute attr : attrs)
  14.530 +                this.flags.add(attr);
  14.531 +        }
  14.532 +
  14.533 +        /**
  14.534 +         * Returns whether or not this TargetType represents an annotation whose
  14.535 +         * target is an inner type of a generic or array type.
  14.536 +         *
  14.537 +         * @return true if this TargetType represents an annotation on an inner
  14.538 +         *         type, false otherwise
  14.539 +         */
  14.540 +        public boolean hasLocation() {
  14.541 +            return flags.contains(HasLocation);
  14.542 +        }
  14.543 +
  14.544 +        public TargetType getGenericComplement() {
  14.545 +            if (hasLocation())
  14.546 +                return this;
  14.547 +            else
  14.548 +                return fromTargetTypeValue(targetTypeValue() + 1);
  14.549 +        }
  14.550 +
  14.551 +        /**
  14.552 +         * Returns whether or not this TargetType represents an annotation whose
  14.553 +         * target has a parameter index.
  14.554 +         *
  14.555 +         * @return true if this TargetType has a parameter index,
  14.556 +         *         false otherwise
  14.557 +         */
  14.558 +        public boolean hasParameter() {
  14.559 +            return flags.contains(HasParameter);
  14.560 +        }
  14.561 +
  14.562 +        /**
  14.563 +         * Returns whether or not this TargetType represents an annotation whose
  14.564 +         * target is a type parameter bound.
  14.565 +         *
  14.566 +         * @return true if this TargetType represents an type parameter bound
  14.567 +         *         annotation, false otherwise
  14.568 +         */
  14.569 +        public boolean hasBound() {
  14.570 +            return flags.contains(HasBound);
  14.571 +        }
  14.572 +
  14.573 +        public int targetTypeValue() {
  14.574 +            return this.targetTypeValue;
  14.575 +        }
  14.576 +
  14.577 +        private static TargetType[] targets = null;
  14.578 +
  14.579 +        private static TargetType[] buildTargets() {
  14.580 +            TargetType[] targets = new TargetType[MAXIMUM_TARGET_TYPE_VALUE + 1];
  14.581 +            TargetType[] alltargets = values();
  14.582 +            for (TargetType target : alltargets)
  14.583 +                if (target.targetTypeValue >= 0)
  14.584 +                    targets[target.targetTypeValue] = target;
  14.585 +            for (int i = 0; i <= MAXIMUM_TARGET_TYPE_VALUE; ++i)
  14.586 +                if (targets[i] == null)
  14.587 +                    targets[i] = UNKNOWN;
  14.588 +            return targets;
  14.589 +        }
  14.590 +
  14.591 +        public static boolean isValidTargetTypeValue(int tag) {
  14.592 +            if (targets == null)
  14.593 +                targets = buildTargets();
  14.594 +
  14.595 +            if (((byte)tag) == ((byte)UNKNOWN.targetTypeValue))
  14.596 +                return true;
  14.597 +
  14.598 +            return (tag >= 0 && tag < targets.length);
  14.599 +        }
  14.600 +
  14.601 +        public static TargetType fromTargetTypeValue(int tag) {
  14.602 +            if (targets == null)
  14.603 +                targets = buildTargets();
  14.604 +
  14.605 +            if (((byte)tag) == ((byte)UNKNOWN.targetTypeValue))
  14.606 +                return UNKNOWN;
  14.607 +
  14.608 +            if (tag < 0 || tag >= targets.length)
  14.609 +                throw new IllegalArgumentException("Unknown TargetType: " + tag);
  14.610 +            return targets[tag];
  14.611 +        }
  14.612 +    }
  14.613 +
  14.614 +    static enum TargetAttribute {
  14.615 +        HasLocation, HasParameter, HasBound;
  14.616 +    }
  14.617 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/src/share/classes/com/sun/tools/classfile/RuntimeInvisibleTypeAnnotations_attribute.java	Sun Jun 28 00:01:09 2009 -0700
    15.3 @@ -0,0 +1,56 @@
    15.4 +/*
    15.5 + * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
    15.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    15.7 + *
    15.8 + * This code is free software; you can redistribute it and/or modify it
    15.9 + * under the terms of the GNU General Public License version 2 only, as
   15.10 + * published by the Free Software Foundation.  Sun designates this
   15.11 + * particular file as subject to the "Classpath" exception as provided
   15.12 + * by Sun in the LICENSE file that accompanied this code.
   15.13 + *
   15.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   15.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   15.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   15.17 + * version 2 for more details (a copy is included in the LICENSE file that
   15.18 + * accompanied this code).
   15.19 + *
   15.20 + * You should have received a copy of the GNU General Public License version
   15.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   15.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   15.23 + *
   15.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   15.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   15.26 + * have any questions.
   15.27 + */
   15.28 +
   15.29 +package com.sun.tools.classfile;
   15.30 +
   15.31 +import java.io.IOException;
   15.32 +
   15.33 +/**
   15.34 + * See JSR 308 specification, section 4.1
   15.35 + *
   15.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   15.37 + *  you write code that depends on this, you do so at your own risk.
   15.38 + *  This code and its internal interfaces are subject to change or
   15.39 + *  deletion without notice.</b>
   15.40 + */
   15.41 +public class RuntimeInvisibleTypeAnnotations_attribute extends RuntimeTypeAnnotations_attribute {
   15.42 +    RuntimeInvisibleTypeAnnotations_attribute(ClassReader cr, int name_index, int length)
   15.43 +            throws IOException, Annotation.InvalidAnnotation {
   15.44 +        super(cr, name_index, length);
   15.45 +    }
   15.46 +
   15.47 +    public RuntimeInvisibleTypeAnnotations_attribute(ConstantPool cp, ExtendedAnnotation[] annotations)
   15.48 +            throws ConstantPoolException {
   15.49 +        this(cp.getUTF8Index(Attribute.RuntimeInvisibleTypeAnnotations), annotations);
   15.50 +    }
   15.51 +
   15.52 +    public RuntimeInvisibleTypeAnnotations_attribute(int name_index, ExtendedAnnotation[] annotations) {
   15.53 +        super(name_index, annotations);
   15.54 +    }
   15.55 +
   15.56 +    public <R, P> R accept(Visitor<R, P> visitor, P p) {
   15.57 +        return visitor.visitRuntimeInvisibleTypeAnnotations(this, p);
   15.58 +    }
   15.59 +}

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/src/share/classes/com/sun/tools/classfile/RuntimeTypeAnnotations_attribute.java	Sun Jun 28 00:01:09 2009 -0700
    16.3 @@ -0,0 +1,61 @@
    16.4 +/*
    16.5 + * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
    16.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    16.7 + *
    16.8 + * This code is free software; you can redistribute it and/or modify it
    16.9 + * under the terms of the GNU General Public License version 2 only, as
   16.10 + * published by the Free Software Foundation.  Sun designates this
   16.11 + * particular file as subject to the "Classpath" exception as provided
   16.12 + * by Sun in the LICENSE file that accompanied this code.
   16.13 + *
   16.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   16.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   16.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   16.17 + * version 2 for more details (a copy is included in the LICENSE file that
   16.18 + * accompanied this code).
   16.19 + *
   16.20 + * You should have received a copy of the GNU General Public License version
   16.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   16.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   16.23 + *
   16.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   16.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   16.26 + * have any questions.
   16.27 + */
   16.28 +
   16.29 +package com.sun.tools.classfile;
   16.30 +
   16.31 +import java.io.IOException;
   16.32 +
   16.33 +/**
   16.34 + * See JSR 308 specification, section 4
   16.35 + *
   16.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   16.37 + *  you write code that depends on this, you do so at your own risk.
   16.38 + *  This code and its internal interfaces are subject to change or
   16.39 + *  deletion without notice.</b>
   16.40 + */
   16.41 +public abstract class RuntimeTypeAnnotations_attribute extends Attribute {
   16.42 +    protected RuntimeTypeAnnotations_attribute(ClassReader cr, int name_index, int length)
   16.43 +            throws IOException, Annotation.InvalidAnnotation {
   16.44 +        super(name_index, length);
   16.45 +        int num_annotations = cr.readUnsignedShort();
   16.46 +        annotations = new ExtendedAnnotation[num_annotations];
   16.47 +        for (int i = 0; i < annotations.length; i++)
   16.48 +            annotations[i] = new ExtendedAnnotation(cr);
   16.49 +    }
   16.50 +
   16.51 +    protected RuntimeTypeAnnotations_attribute(int name_index, ExtendedAnnotation[] annotations) {
   16.52 +        super(name_index, length(annotations));
   16.53 +        this.annotations = annotations;
   16.54 +    }
   16.55 +
   16.56 +    private static int length(ExtendedAnnotation[] annos) {
   16.57 +        int n = 2;
   16.58 +        for (ExtendedAnnotation anno: annos)
   16.59 +            n += anno.length();
   16.60 +        return n;
   16.61 +    }
   16.62 +
   16.63 +    public final ExtendedAnnotation[] annotations;
   16.64 +}

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/src/share/classes/com/sun/tools/classfile/RuntimeVisibleTypeAnnotations_attribute.java	Sun Jun 28 00:01:09 2009 -0700
    17.3 @@ -0,0 +1,56 @@
    17.4 +/*
    17.5 + * Copyright 2007-2008 Sun Microsystems, Inc.  All Rights Reserved.
    17.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    17.7 + *
    17.8 + * This code is free software; you can redistribute it and/or modify it
    17.9 + * under the terms of the GNU General Public License version 2 only, as
   17.10 + * published by the Free Software Foundation.  Sun designates this
   17.11 + * particular file as subject to the "Classpath" exception as provided
   17.12 + * by Sun in the LICENSE file that accompanied this code.
   17.13 + *
   17.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   17.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   17.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   17.17 + * version 2 for more details (a copy is included in the LICENSE file that
   17.18 + * accompanied this code).
   17.19 + *
   17.20 + * You should have received a copy of the GNU General Public License version
   17.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   17.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   17.23 + *
   17.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   17.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   17.26 + * have any questions.
   17.27 + */
   17.28 +
   17.29 +package com.sun.tools.classfile;
   17.30 +
   17.31 +import java.io.IOException;
   17.32 +
   17.33 +/**
   17.34 + * See JSR 308 specification, section 4.1
   17.35 + *
   17.36 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   17.37 + *  you write code that depends on this, you do so at your own risk.
   17.38 + *  This code and its internal interfaces are subject to change or
   17.39 + *  deletion without notice.</b>
   17.40 + */
   17.41 +public class RuntimeVisibleTypeAnnotations_attribute extends RuntimeTypeAnnotations_attribute {
   17.42 +    RuntimeVisibleTypeAnnotations_attribute(ClassReader cr, int name_index, int length)
   17.43 +            throws IOException, Annotation.InvalidAnnotation {
   17.44 +        super(cr, name_index, length);
   17.45 +    }
   17.46 +
   17.47 +    public RuntimeVisibleTypeAnnotations_attribute(ConstantPool cp, ExtendedAnnotation[] annotations)
   17.48 +            throws ConstantPoolException {
   17.49 +        this(cp.getUTF8Index(Attribute.RuntimeVisibleTypeAnnotations), annotations);
   17.50 +    }
   17.51 +
   17.52 +    public RuntimeVisibleTypeAnnotations_attribute(int name_index, ExtendedAnnotation[] annotations) {
   17.53 +        super(name_index, annotations);
   17.54 +    }
   17.55 +
   17.56 +    public <R, P> R accept(Visitor<R, P> visitor, P p) {
   17.57 +        return visitor.visitRuntimeVisibleTypeAnnotations(this, p);
   17.58 +    }
   17.59 +}

    18.1 --- a/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java	Fri Jun 26 10:26:27 2009 -0700
    18.2 +++ b/src/share/classes/com/sun/tools/javac/api/JavacTaskImpl.java	Sun Jun 28 00:01:09 2009 -0700
    18.3 @@ -133,6 +133,7 @@
    18.4      public Boolean call() {
    18.5          if (!used.getAndSet(true)) {
    18.6              beginContext();
    18.7 +            notYetEntered = new HashMap<JavaFileObject, JCCompilationUnit>();
    18.8              try {
    18.9                  compilerMain.setFatalErrors(true);
   18.10                  result = compilerMain.compile(args, context, fileObjects, processors);
   18.11 @@ -143,6 +144,7 @@
   18.12              args = null;
   18.13              context = null;
   18.14              fileObjects = null;
   18.15 +            notYetEntered = null;
   18.16              return result == 0;
   18.17          } else {
   18.18              throw new IllegalStateException("multiple calls to method 'call'");

    19.1 --- a/src/share/classes/com/sun/tools/javac/api/JavacTrees.java	Fri Jun 26 10:26:27 2009 -0700
    19.2 +++ b/src/share/classes/com/sun/tools/javac/api/JavacTrees.java	Sun Jun 28 00:01:09 2009 -0700
    19.3 @@ -35,6 +35,7 @@
    19.4  import javax.lang.model.element.TypeElement;
    19.5  import javax.lang.model.type.DeclaredType;
    19.6  import javax.lang.model.type.TypeMirror;
    19.7 +import javax.tools.Diagnostic;
    19.8  import javax.tools.JavaCompiler;
    19.9  import javax.tools.JavaFileObject;
   19.10  
   19.11 @@ -54,6 +55,7 @@
   19.12  import com.sun.tools.javac.comp.MemberEnter;
   19.13  import com.sun.tools.javac.comp.Resolve;
   19.14  import com.sun.tools.javac.model.JavacElements;
   19.15 +import com.sun.tools.javac.processing.JavacMessager;
   19.16  import com.sun.tools.javac.processing.JavacProcessingEnvironment;
   19.17  import com.sun.tools.javac.tree.JCTree.*;
   19.18  import com.sun.tools.javac.tree.JCTree;
   19.19 @@ -61,6 +63,7 @@
   19.20  import com.sun.tools.javac.tree.TreeInfo;
   19.21  import com.sun.tools.javac.tree.TreeMaker;
   19.22  import com.sun.tools.javac.util.Context;
   19.23 +import com.sun.tools.javac.util.JCDiagnostic;
   19.24  import com.sun.tools.javac.util.List;
   19.25  import com.sun.tools.javac.util.Log;
   19.26  import com.sun.tools.javac.util.Pair;
   19.27 @@ -336,4 +339,54 @@
   19.28  
   19.29          return com.sun.tools.javac.code.Type.noType;
   19.30      }
   19.31 +
   19.32 +    /**
   19.33 +     * Prints a message of the specified kind at the location of the
   19.34 +     * tree within the provided compilation unit
   19.35 +     *
   19.36 +     * @param kind the kind of message
   19.37 +     * @param msg  the message, or an empty string if none
   19.38 +     * @param t    the tree to use as a position hint
   19.39 +     * @param root the compilation unit that contains tree
   19.40 +     */
   19.41 +    public void printMessage(Diagnostic.Kind kind, CharSequence msg,
   19.42 +            com.sun.source.tree.Tree t,
   19.43 +            com.sun.source.tree.CompilationUnitTree root) {
   19.44 +        JavaFileObject oldSource = null;
   19.45 +        JavaFileObject newSource = null;
   19.46 +        JCDiagnostic.DiagnosticPosition pos = null;
   19.47 +
   19.48 +        newSource = root.getSourceFile();
   19.49 +        if (newSource != null) {
   19.50 +            oldSource = log.useSource(newSource);
   19.51 +            pos = ((JCTree) t).pos();
   19.52 +        }
   19.53 +
   19.54 +        try {
   19.55 +            switch (kind) {
   19.56 +            case ERROR:
   19.57 +                boolean prev = log.multipleErrors;
   19.58 +                try {
   19.59 +                    log.error(pos, "proc.messager", msg.toString());
   19.60 +                } finally {
   19.61 +                    log.multipleErrors = prev;
   19.62 +                }
   19.63 +                break;
   19.64 +
   19.65 +            case WARNING:
   19.66 +                log.warning(pos, "proc.messager", msg.toString());
   19.67 +                break;
   19.68 +
   19.69 +            case MANDATORY_WARNING:
   19.70 +                log.mandatoryWarning(pos, "proc.messager", msg.toString());
   19.71 +                break;
   19.72 +
   19.73 +            default:
   19.74 +                log.note(pos, "proc.messager", msg.toString());
   19.75 +            }
   19.76 +        } finally {
   19.77 +            if (oldSource != null)
   19.78 +                log.useSource(oldSource);
   19.79 +        }
   19.80 +    }
   19.81  }

    20.1 --- a/src/share/classes/com/sun/tools/javac/code/Attribute.java	Fri Jun 26 10:26:27 2009 -0700
    20.2 +++ b/src/share/classes/com/sun/tools/javac/code/Attribute.java	Sun Jun 28 00:01:09 2009 -0700
    20.3 @@ -204,6 +204,21 @@
    20.4          }
    20.5      }
    20.6  
    20.7 +    public static class TypeCompound extends Compound {
    20.8 +        public TypeAnnotationPosition position;
    20.9 +        public TypeCompound(Compound compound,
   20.10 +                TypeAnnotationPosition position) {
   20.11 +            this(compound.type, compound.values, position);
   20.12 +        }
   20.13 +        public TypeCompound(Type type,
   20.14 +                List<Pair<MethodSymbol, Attribute>> values,
   20.15 +                TypeAnnotationPosition position) {
   20.16 +            super(type, values);
   20.17 +            this.position = position;
   20.18 +        }
   20.19 +
   20.20 +    }
   20.21 +
   20.22      /** The value for an annotation element of an array type.
   20.23       */
   20.24      public static class Array extends Attribute {

    21.1 --- a/src/share/classes/com/sun/tools/javac/code/Source.java	Fri Jun 26 10:26:27 2009 -0700
    21.2 +++ b/src/share/classes/com/sun/tools/javac/code/Source.java	Sun Jun 28 00:01:09 2009 -0700
    21.3 @@ -153,6 +153,9 @@
    21.4      public boolean enforceMandatoryWarnings() {
    21.5          return compareTo(JDK1_5) >= 0;
    21.6      }
    21.7 +    public boolean allowTypeAnnotations() {
    21.8 +        return compareTo(JDK1_7) >= 0;
    21.9 +    }
   21.10      public static SourceVersion toSourceVersion(Source source) {
   21.11          switch(source) {
   21.12          case JDK1_2:

    22.1 --- a/src/share/classes/com/sun/tools/javac/code/Symbol.java	Fri Jun 26 10:26:27 2009 -0700
    22.2 +++ b/src/share/classes/com/sun/tools/javac/code/Symbol.java	Sun Jun 28 00:01:09 2009 -0700
    22.3 @@ -100,6 +100,17 @@
    22.4       */
    22.5      public Type type;
    22.6  
    22.7 +    /** The type annotations targeted to a tree directly owned by this symbol
    22.8 +     */
    22.9 +    // type annotations are stored here for two purposes:
   22.10 +    //  - convenient location to store annotations for generation after erasure
   22.11 +    //  - a private interface for accessing type annotations parsed from
   22.12 +    //    classfiles
   22.13 +    //  the field is populated for the following declaration only
   22.14 +    //  class, field, variable and type parameters
   22.15 +    //
   22.16 +    public List<Attribute.TypeCompound> typeAnnotations;
   22.17 +
   22.18      /** The owner of this symbol.
   22.19       */
   22.20      public Symbol owner;
   22.21 @@ -122,6 +133,7 @@
   22.22          this.completer = null;
   22.23          this.erasure_field = null;
   22.24          this.attributes_field = List.nil();
   22.25 +        this.typeAnnotations = List.nil();
   22.26          this.name = name;
   22.27      }
   22.28  

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/src/share/classes/com/sun/tools/javac/code/TargetType.java	Sun Jun 28 00:01:09 2009 -0700
    23.3 @@ -0,0 +1,277 @@
    23.4 +/*
    23.5 + * Copyright 2008-2009 Sun Microsystems, Inc.  All Rights Reserved.
    23.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    23.7 + *
    23.8 + * This code is free software; you can redistribute it and/or modify it
    23.9 + * under the terms of the GNU General Public License version 2 only, as
   23.10 + * published by the Free Software Foundation.  Sun designates this
   23.11 + * particular file as subject to the "Classpath" exception as provided
   23.12 + * by Sun in the LICENSE file that accompanied this code.
   23.13 + *
   23.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   23.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   23.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   23.17 + * version 2 for more details (a copy is included in the LICENSE file that
   23.18 + * accompanied this code).
   23.19 + *
   23.20 + * You should have received a copy of the GNU General Public License version
   23.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   23.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   23.23 + *
   23.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   23.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   23.26 + * have any questions.
   23.27 + */
   23.28 +
   23.29 +package com.sun.tools.javac.code;
   23.30 +
   23.31 +import static com.sun.tools.javac.code.TargetType.TargetAttribute.*;
   23.32 +
   23.33 +import java.util.EnumSet;
   23.34 +import java.util.Set;
   23.35 +
   23.36 +/**
   23.37 + * Describes the type of program element an extended annotation (or extended
   23.38 + * compound attribute) targets.
   23.39 + *
   23.40 + * By comparison, a Tree.Kind has enum values for all elements in the AST, and
   23.41 + * it does not provide enough resolution for type arguments (i.e., whether an
   23.42 + * annotation targets a type argument in a local variable, method return type,
   23.43 + * or a typecast).
   23.44 + *
   23.45 + *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   23.46 + *  you write code that depends on this, you do so at your own risk.
   23.47 + *  This code and its internal interfaces are subject to change or
   23.48 + *  deletion without notice.</b>
   23.49 + */
   23.50 +public enum TargetType {
   23.51 +
   23.52 +    //
   23.53 +    // Some target types are commented out, because Java doesn't permit such
   23.54 +    // targets.  They are included here to confirm that their omission is
   23.55 +    // intentional omission not an accidental omission.
   23.56 +    //
   23.57 +
   23.58 +    /** For annotations on typecasts. */
   23.59 +    TYPECAST(0x00, IsLocal),
   23.60 +
   23.61 +    /** For annotations on a type argument or nested array of a typecast. */
   23.62 +    TYPECAST_GENERIC_OR_ARRAY(0x01, HasLocation, IsLocal),
   23.63 +
   23.64 +    /** For annotations on type tests. */
   23.65 +    INSTANCEOF(0x02, IsLocal),
   23.66 +
   23.67 +    /** For annotations on a type argument or nested array of a type test. */
   23.68 +    INSTANCEOF_GENERIC_OR_ARRAY(0x03, HasLocation, IsLocal),
   23.69 +
   23.70 +    /** For annotations on object creation expressions. */
   23.71 +    NEW(0x04, IsLocal),
   23.72 +
   23.73 +    /**
   23.74 +     * For annotations on a type argument or nested array of an object creation
   23.75 +     * expression.
   23.76 +     */
   23.77 +    NEW_GENERIC_OR_ARRAY(0x05, HasLocation, IsLocal),
   23.78 +
   23.79 +
   23.80 +    /** For annotations on the method receiver. */
   23.81 +    METHOD_RECEIVER(0x06),
   23.82 +
   23.83 +    // invalid location
   23.84 +    //@Deprecated METHOD_RECEIVER_GENERIC_OR_ARRAY(0x07, HasLocation),
   23.85 +
   23.86 +    /** For annotations on local variables. */
   23.87 +    LOCAL_VARIABLE(0x08, IsLocal),
   23.88 +
   23.89 +    /** For annotations on a type argument or nested array of a local. */
   23.90 +    LOCAL_VARIABLE_GENERIC_OR_ARRAY(0x09, HasLocation, IsLocal),
   23.91 +
   23.92 +    // handled by regular annotations
   23.93 +    //@Deprecated METHOD_RETURN(0x0A),
   23.94 +
   23.95 +    /**
   23.96 +     * For annotations on a type argument or nested array of a method return
   23.97 +     * type.
   23.98 +     */
   23.99 +    METHOD_RETURN_GENERIC_OR_ARRAY(0x0B, HasLocation),
  23.100 +
  23.101 +    // handled by regular annotations
  23.102 +    //@Deprecated METHOD_PARAMETER(0x0C),
  23.103 +
  23.104 +    /** For annotations on a type argument or nested array of a method parameter. */
  23.105 +    METHOD_PARAMETER_GENERIC_OR_ARRAY(0x0D, HasLocation),
  23.106 +
  23.107 +    // handled by regular annotations
  23.108 +    //@Deprecated FIELD(0x0E),
  23.109 +
  23.110 +    /** For annotations on a type argument or nested array of a field. */
  23.111 +    FIELD_GENERIC_OR_ARRAY(0x0F, HasLocation),
  23.112 +
  23.113 +    /** For annotations on a bound of a type parameter of a class. */
  23.114 +    CLASS_TYPE_PARAMETER_BOUND(0x10, HasBound, HasParameter),
  23.115 +
  23.116 +    /**
  23.117 +     * For annotations on a type argument or nested array of a bound of a type
  23.118 +     * parameter of a class.
  23.119 +     */
  23.120 +    CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY(0x11, HasBound, HasLocation, HasParameter),
  23.121 +
  23.122 +    /** For annotations on a bound of a type parameter of a method. */
  23.123 +    METHOD_TYPE_PARAMETER_BOUND(0x12, HasBound, HasParameter),
  23.124 +
  23.125 +    /**
  23.126 +     * For annotations on a type argument or nested array of a bound of a type
  23.127 +     * parameter of a method.
  23.128 +     */
  23.129 +    METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY(0x13, HasBound, HasLocation, HasParameter),
  23.130 +
  23.131 +    /** For annotations on the type of an "extends" or "implements" clause. */
  23.132 +    CLASS_EXTENDS(0x14),
  23.133 +
  23.134 +    /** For annotations on the inner type of an "extends" or "implements" clause. */
  23.135 +    CLASS_EXTENDS_GENERIC_OR_ARRAY(0x15, HasLocation),
  23.136 +
  23.137 +    /** For annotations on a throws clause in a method declaration. */
  23.138 +    THROWS(0x16),
  23.139 +
  23.140 +    // invalid location
  23.141 +    //@Deprecated THROWS_GENERIC_OR_ARRAY(0x17, HasLocation),
  23.142 +
  23.143 +    /** For annotations in type arguments of object creation expressions. */
  23.144 +    NEW_TYPE_ARGUMENT(0x18, IsLocal),
  23.145 +    NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY(0x19, HasLocation, IsLocal),
  23.146 +
  23.147 +    METHOD_TYPE_ARGUMENT(0x1A, IsLocal),
  23.148 +    METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY(0x1B, HasLocation, IsLocal),
  23.149 +
  23.150 +    WILDCARD_BOUND(0x1C, HasBound),
  23.151 +    WILDCARD_BOUND_GENERIC_OR_ARRAY(0x1D, HasBound, HasLocation),
  23.152 +
  23.153 +    CLASS_LITERAL(0x1E, IsLocal),
  23.154 +    CLASS_LITERAL_GENERIC_OR_ARRAY(0x1F, HasLocation, IsLocal),
  23.155 +
  23.156 +    METHOD_TYPE_PARAMETER(0x20, HasParameter),
  23.157 +
  23.158 +    // invalid location
  23.159 +    //@Deprecated METHOD_TYPE_PARAMETER_GENERIC_OR_ARRAY(0x21, HasLocation, HasParameter),
  23.160 +
  23.161 +    CLASS_TYPE_PARAMETER(0x22, HasParameter),
  23.162 +
  23.163 +    // invalid location
  23.164 +    //@Deprecated CLASS_TYPE_PARAMETER_GENERIC_OR_ARRAY(0x23, HasLocation, HasParameter),
  23.165 +
  23.166 +    /** For annotations with an unknown target. */
  23.167 +    UNKNOWN(-1);
  23.168 +
  23.169 +    static final int MAXIMUM_TARGET_TYPE_VALUE = 0x22;
  23.170 +
  23.171 +    private final int targetTypeValue;
  23.172 +    private Set<TargetAttribute> flags;
  23.173 +
  23.174 +    TargetType(int targetTypeValue, TargetAttribute... attributes) {
  23.175 +        if (targetTypeValue < Byte.MIN_VALUE
  23.176 +                || targetTypeValue > Byte.MAX_VALUE)
  23.177 +                throw new AssertionError("attribute type value needs to be a byte: " + targetTypeValue);
  23.178 +        this.targetTypeValue = (byte)targetTypeValue;
  23.179 +        flags = EnumSet.noneOf(TargetAttribute.class);
  23.180 +        for (TargetAttribute attr : attributes)
  23.181 +            flags.add(attr);
  23.182 +    }
  23.183 +
  23.184 +    /**
  23.185 +     * Returns whether or not this TargetType represents an annotation whose
  23.186 +     * target is an inner type of a generic or array type.
  23.187 +     *
  23.188 +     * @return true if this TargetType represents an annotation on an inner
  23.189 +     *         type, false otherwise
  23.190 +     */
  23.191 +    public boolean hasLocation() {
  23.192 +        return flags.contains(HasLocation);
  23.193 +    }
  23.194 +
  23.195 +    public TargetType getGenericComplement() {
  23.196 +        if (hasLocation())
  23.197 +            return this;
  23.198 +        else
  23.199 +            return fromTargetTypeValue(targetTypeValue() + 1);
  23.200 +    }
  23.201 +
  23.202 +    /**
  23.203 +     * Returns whether or not this TargetType represents an annotation whose
  23.204 +     * target has a parameter index.
  23.205 +     *
  23.206 +     * @return true if this TargetType has a parameter index,
  23.207 +     *         false otherwise
  23.208 +     */
  23.209 +    public boolean hasParameter() {
  23.210 +        return flags.contains(HasParameter);
  23.211 +    }
  23.212 +
  23.213 +    /**
  23.214 +     * Returns whether or not this TargetType represents an annotation whose
  23.215 +     * target is a type parameter bound.
  23.216 +     *
  23.217 +     * @return true if this TargetType represents an type parameter bound
  23.218 +     *         annotation, false otherwise
  23.219 +     */
  23.220 +    public boolean hasBound() {
  23.221 +        return flags.contains(HasBound);
  23.222 +    }
  23.223 +
  23.224 +    /**
  23.225 +     * Returns whether or not this TargetType represents an annotation whose
  23.226 +     * target is exclusively a tree in a method body
  23.227 +     *
  23.228 +     * Note: wildcard bound targets could target a local tree and a class
  23.229 +     * member declaration signature tree
  23.230 +     */
  23.231 +    public boolean isLocal() {
  23.232 +        return flags.contains(IsLocal);
  23.233 +    }
  23.234 +
  23.235 +    public int targetTypeValue() {
  23.236 +        return this.targetTypeValue;
  23.237 +    }
  23.238 +
  23.239 +    private static TargetType[] targets = null;
  23.240 +
  23.241 +    private static TargetType[] buildTargets() {
  23.242 +        TargetType[] targets = new TargetType[MAXIMUM_TARGET_TYPE_VALUE + 1];
  23.243 +        TargetType[] alltargets = values();
  23.244 +        for (TargetType target : alltargets) {
  23.245 +            if (target.targetTypeValue >= 0)
  23.246 +                targets[target.targetTypeValue] = target;
  23.247 +        }
  23.248 +        for (int i = 0; i <= MAXIMUM_TARGET_TYPE_VALUE; ++i) {
  23.249 +            if (targets[i] == null)
  23.250 +                targets[i] = UNKNOWN;
  23.251 +        }
  23.252 +        return targets;
  23.253 +    }
  23.254 +
  23.255 +    public static boolean isValidTargetTypeValue(int tag) {
  23.256 +        if (targets == null)
  23.257 +            targets = buildTargets();
  23.258 +
  23.259 +        if (((byte)tag) == ((byte)UNKNOWN.targetTypeValue))
  23.260 +            return true;
  23.261 +
  23.262 +        return (tag >= 0 && tag < targets.length);
  23.263 +    }
  23.264 +
  23.265 +    public static TargetType fromTargetTypeValue(int tag) {
  23.266 +        if (targets == null)
  23.267 +            targets = buildTargets();
  23.268 +
  23.269 +        if (((byte)tag) == ((byte)UNKNOWN.targetTypeValue))
  23.270 +            return UNKNOWN;
  23.271 +
  23.272 +        if (tag < 0 || tag >= targets.length)
  23.273 +            throw new IllegalArgumentException("Unknown TargetType: " + tag);
  23.274 +        return targets[tag];
  23.275 +    }
  23.276 +
  23.277 +    static enum TargetAttribute {
  23.278 +        HasLocation, HasParameter, HasBound, IsLocal;
  23.279 +    }
  23.280 +}

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/src/share/classes/com/sun/tools/javac/code/TypeAnnotationPosition.java	Sun Jun 28 00:01:09 2009 -0700
    24.3 @@ -0,0 +1,194 @@
    24.4 +/*
    24.5 + * Copyright 2003-2008 Sun Microsystems, Inc.  All Rights Reserved.
    24.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    24.7 + *
    24.8 + * This code is free software; you can redistribute it and/or modify it
    24.9 + * under the terms of the GNU General Public License version 2 only, as
   24.10 + * published by the Free Software Foundation.  Sun designates this
   24.11 + * particular file as subject to the "Classpath" exception as provided
   24.12 + * by Sun in the LICENSE file that accompanied this code.
   24.13 + *
   24.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   24.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   24.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   24.17 + * version 2 for more details (a copy is included in the LICENSE file that
   24.18 + * accompanied this code).
   24.19 + *
   24.20 + * You should have received a copy of the GNU General Public License version
   24.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   24.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   24.23 + *
   24.24 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
   24.25 + * CA 95054 USA or visit www.sun.com if you need additional information or
   24.26 + * have any questions.
   24.27 + */
   24.28 +
   24.29 +package com.sun.tools.javac.code;
   24.30 +
   24.31 +import com.sun.tools.javac.util.*;
   24.32 +
   24.33 +/** A type annotation position.
   24.34 +*
   24.35 +*  <p><b>This is NOT part of any API supported by Sun Microsystems.  If
   24.36 +*  you write code that depends on this, you do so at your own risk.
   24.37 +*  This code and its internal interfaces are subject to change or
   24.38 +*  deletion without notice.</b>
   24.39 +*/
   24.40 +public class TypeAnnotationPosition {
   24.41 +
   24.42 +    public TargetType type = TargetType.UNKNOWN;
   24.43 +
   24.44 +    // For generic/array types.
   24.45 +    public List<Integer> location = List.nil();
   24.46 +
   24.47 +    // Tree position.
   24.48 +    public int pos = -1;
   24.49 +
   24.50 +    // For typecasts, type tests, new (and locals, as start_pc).
   24.51 +    public boolean isValidOffset = false;
   24.52 +    public int offset = -1;
   24.53 +
   24.54 +    // For locals. arrays same length
   24.55 +    public int[] lvarOffset = new int[] { -1 };
   24.56 +    public int[] lvarLength = new int[] { -1 };
   24.57 +    public int[] lvarIndex = new int[] { -1 };
   24.58 +
   24.59 +    // For type parameter bound
   24.60 +    public int bound_index = -1;
   24.61 +
   24.62 +    // For type parameter and method parameter
   24.63 +    public int parameter_index = -1;
   24.64 +
   24.65 +    // For class extends, implements, and throws classes
   24.66 +    public int type_index = -2;
   24.67 +
   24.68 +    // For wildcards
   24.69 +    public TypeAnnotationPosition wildcard_position = null;
   24.70 +
   24.71 +    @Override
   24.72 +    public String toString() {
   24.73 +        StringBuilder sb = new StringBuilder();
   24.74 +        sb.append('[');
   24.75 +        sb.append(type);
   24.76 +
   24.77 +        switch (type) {
   24.78 +        // type case
   24.79 +        case TYPECAST:
   24.80 +        case TYPECAST_GENERIC_OR_ARRAY:
   24.81 +            // object creation
   24.82 +        case INSTANCEOF:
   24.83 +        case INSTANCEOF_GENERIC_OR_ARRAY:
   24.84 +            // new expression
   24.85 +        case NEW:
   24.86 +        case NEW_GENERIC_OR_ARRAY:
   24.87 +        case NEW_TYPE_ARGUMENT:
   24.88 +        case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
   24.89 +            sb.append(", offset = ");
   24.90 +            sb.append(offset);
   24.91 +            break;
   24.92 +            // local variable
   24.93 +        case LOCAL_VARIABLE:
   24.94 +        case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
   24.95 +            sb.append(", {");
   24.96 +            for (int i = 0; i < lvarOffset.length; ++i) {
   24.97 +                if (i != 0) sb.append("; ");
   24.98 +                sb.append(", start_pc = ");
   24.99 +                sb.append(lvarOffset[i]);
  24.100 +                sb.append(", length = ");
  24.101 +                sb.append(lvarLength[i]);
  24.102 +                sb.append(", index = ");
  24.103 +                sb.append(lvarIndex[i]);
  24.104 +            }
  24.105 +            sb.append("}");
  24.106 +            break;
  24.107 +            // method receiver
  24.108 +        case METHOD_RECEIVER:
  24.109 +            // Do nothing
  24.110 +            break;
  24.111 +            // type parameters
  24.112 +        case CLASS_TYPE_PARAMETER:
  24.113 +        case METHOD_TYPE_PARAMETER:
  24.114 +            sb.append(", param_index = ");
  24.115 +            sb.append(parameter_index);
  24.116 +            break;
  24.117 +            // type parameters bound
  24.118 +        case CLASS_TYPE_PARAMETER_BOUND:
  24.119 +        case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  24.120 +        case METHOD_TYPE_PARAMETER_BOUND:
  24.121 +        case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  24.122 +            sb.append(", param_index = ");
  24.123 +            sb.append(parameter_index);
  24.124 +            sb.append(", bound_index = ");
  24.125 +            sb.append(bound_index);
  24.126 +            break;
  24.127 +            // wildcard
  24.128 +        case WILDCARD_BOUND:
  24.129 +        case WILDCARD_BOUND_GENERIC_OR_ARRAY:
  24.130 +            sb.append(", wild_card = ");
  24.131 +            sb.append(wildcard_position);
  24.132 +            break;
  24.133 +            // Class extends and implements clauses
  24.134 +        case CLASS_EXTENDS:
  24.135 +        case CLASS_EXTENDS_GENERIC_OR_ARRAY:
  24.136 +            sb.append(", type_index = ");
  24.137 +            sb.append(type_index);
  24.138 +            break;
  24.139 +            // throws
  24.140 +        case THROWS:
  24.141 +            sb.append(", type_index = ");
  24.142 +            sb.append(type_index);
  24.143 +            break;
  24.144 +        case CLASS_LITERAL:
  24.145 +            sb.append(", offset = ");
  24.146 +            sb.append(offset);
  24.147 +            break;
  24.148 +            // method parameter: not specified
  24.149 +        case METHOD_PARAMETER_GENERIC_OR_ARRAY:
  24.150 +            sb.append(", param_index = ");
  24.151 +            sb.append(parameter_index);
  24.152 +            break;
  24.153 +            // method type argument: wasn't specified
  24.154 +        case METHOD_TYPE_ARGUMENT:
  24.155 +        case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  24.156 +            sb.append(", offset = ");
  24.157 +            sb.append(offset);
  24.158 +            sb.append(", type_index = ");
  24.159 +            sb.append(type_index);
  24.160 +            break;
  24.161 +            // We don't need to worry abut these
  24.162 +        case METHOD_RETURN_GENERIC_OR_ARRAY:
  24.163 +        case FIELD_GENERIC_OR_ARRAY:
  24.164 +            break;
  24.165 +        case UNKNOWN:
  24.166 +            break;
  24.167 +        default:
  24.168 +            //                throw new AssertionError("unknown type: " + type);
  24.169 +        }
  24.170 +
  24.171 +        // Append location data for generics/arrays.
  24.172 +        if (type.hasLocation()) {
  24.173 +            sb.append(", location = (");
  24.174 +            sb.append(location);
  24.175 +            sb.append(")");
  24.176 +        }
  24.177 +
  24.178 +        sb.append(", pos = ");
  24.179 +        sb.append(pos);
  24.180 +
  24.181 +        sb.append(']');
  24.182 +        return sb.toString();
  24.183 +    }
  24.184 +
  24.185 +    /**
  24.186 +     * Indicates whether the target tree of the annotation has been optimized
  24.187 +     * away from classfile or not.
  24.188 +     * @return true if the target has not been optimized away
  24.189 +     */
  24.190 +    public boolean emitToClassfile() {
  24.191 +        if (type == TargetType.WILDCARD_BOUND
  24.192 +            || type == TargetType.WILDCARD_BOUND_GENERIC_OR_ARRAY)
  24.193 +            return wildcard_position.isValidOffset;
  24.194 +        else
  24.195 +            return !type.isLocal() || isValidOffset;
  24.196 +    }
  24.197 +}

    25.1 --- a/src/share/classes/com/sun/tools/javac/comp/Attr.java	Fri Jun 26 10:26:27 2009 -0700
    25.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Attr.java	Sun Jun 28 00:01:09 2009 -0700
    25.3 @@ -700,7 +700,6 @@
    25.4              localEnv.info.scope.leave();
    25.5              result = tree.type = m.type;
    25.6              chk.validateAnnotations(tree.mods.annotations, m);
    25.7 -
    25.8          }
    25.9          finally {
   25.10              chk.setLint(prevLint);
   25.11 @@ -2516,10 +2515,11 @@
   25.12                  Type clazzOuter = clazztype.getEnclosingType();
   25.13                  if (clazzOuter.tag == CLASS) {
   25.14                      Type site;
   25.15 -                    if (tree.clazz.getTag() == JCTree.IDENT) {
   25.16 +                    JCExpression clazz = TreeInfo.typeIn(tree.clazz);
   25.17 +                    if (clazz.getTag() == JCTree.IDENT) {
   25.18                          site = env.enclClass.sym.type;
   25.19 -                    } else if (tree.clazz.getTag() == JCTree.SELECT) {
   25.20 -                        site = ((JCFieldAccess) tree.clazz).selected.type;
   25.21 +                    } else if (clazz.getTag() == JCTree.SELECT) {
   25.22 +                        site = ((JCFieldAccess) clazz).selected.type;
   25.23                      } else throw new AssertionError(""+tree);
   25.24                      if (clazzOuter.tag == CLASS && site != clazzOuter) {
   25.25                          if (site.tag == CLASS)
   25.26 @@ -2628,6 +2628,10 @@
   25.27          result = tree.type = syms.errType;
   25.28      }
   25.29  
   25.30 +    public void visitAnnotatedType(JCAnnotatedType tree) {
   25.31 +        result = tree.type = attribType(tree.getUnderlyingType(), env);
   25.32 +    }
   25.33 +
   25.34      public void visitErroneous(JCErroneous tree) {
   25.35          if (tree.errs != null)
   25.36              for (JCTree err : tree.errs)
   25.37 @@ -2816,6 +2820,9 @@
   25.38              (c.flags() & ABSTRACT) == 0) {
   25.39              checkSerialVersionUID(tree, c);
   25.40          }
   25.41 +
   25.42 +        // Check type annotations applicability rules
   25.43 +        validateTypeAnnotations(tree);
   25.44      }
   25.45          // where
   25.46          /** check if a class is a subtype of Serializable, if that is available. */
   25.47 @@ -2858,4 +2865,33 @@
   25.48      private Type capture(Type type) {
   25.49          return types.capture(type);
   25.50      }
   25.51 +
   25.52 +    private void validateTypeAnnotations(JCTree tree) {
   25.53 +        tree.accept(typeAnnotationsValidator);
   25.54 +    }
   25.55 +    //where
   25.56 +    private final JCTree.Visitor typeAnnotationsValidator =
   25.57 +        new TreeScanner() {
   25.58 +        public void visitAnnotation(JCAnnotation tree) {
   25.59 +            if (tree instanceof JCTypeAnnotation) {
   25.60 +                chk.validateTypeAnnotation((JCTypeAnnotation)tree, false);
   25.61 +            }
   25.62 +            super.visitAnnotation(tree);
   25.63 +        }
   25.64 +        public void visitTypeParameter(JCTypeParameter tree) {
   25.65 +            chk.validateTypeAnnotations(tree.annotations, true);
   25.66 +            // don't call super. skip type annotations
   25.67 +            scan(tree.bounds);
   25.68 +        }
   25.69 +        public void visitMethodDef(JCMethodDecl tree) {
   25.70 +            // need to check static methods
   25.71 +            if ((tree.sym.flags() & Flags.STATIC) != 0) {
   25.72 +                for (JCTypeAnnotation a : tree.receiverAnnotations) {
   25.73 +                    if (chk.isTypeAnnotation(a, false))
   25.74 +                        log.error(a.pos(), "annotation.type.not.applicable");
   25.75 +                }
   25.76 +            }
   25.77 +            super.visitMethodDef(tree);
   25.78 +        }
   25.79 +    };
   25.80  }

    26.1 --- a/src/share/classes/com/sun/tools/javac/comp/Check.java	Fri Jun 26 10:26:27 2009 -0700
    26.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Check.java	Sun Jun 28 00:01:09 2009 -0700
    26.3 @@ -916,6 +916,10 @@
    26.4              }
    26.5          }
    26.6  
    26.7 +        public void visitAnnotatedType(JCAnnotatedType tree) {
    26.8 +            tree.underlyingType.accept(this);
    26.9 +        }
   26.10 +
   26.11          /** Default visitor method: do nothing.
   26.12           */
   26.13          public void visitTree(JCTree tree) {
   26.14 @@ -1806,6 +1810,14 @@
   26.15              validateAnnotation(a, s);
   26.16      }
   26.17  
   26.18 +    /** Check the type annotations
   26.19 +     */
   26.20 +    public void validateTypeAnnotations(List<JCTypeAnnotation> annotations, boolean isTypeParameter) {
   26.21 +        if (skipAnnotations) return;
   26.22 +        for (JCTypeAnnotation a : annotations)
   26.23 +            validateTypeAnnotation(a, isTypeParameter);
   26.24 +    }
   26.25 +
   26.26      /** Check an annotation of a symbol.
   26.27       */
   26.28      public void validateAnnotation(JCAnnotation a, Symbol s) {
   26.29 @@ -1820,6 +1832,15 @@
   26.30          }
   26.31      }
   26.32  
   26.33 +    public void validateTypeAnnotation(JCTypeAnnotation a, boolean isTypeParameter) {
   26.34 +        if (a.type == null)
   26.35 +            throw new AssertionError("annotation tree hasn't been attributed yet: " + a);
   26.36 +        validateAnnotation(a);
   26.37 +
   26.38 +        if (!isTypeAnnotation(a, isTypeParameter))
   26.39 +            log.error(a.pos(), "annotation.type.not.applicable");
   26.40 +    }
   26.41 +
   26.42      /** Is s a method symbol that overrides a method in a superclass? */
   26.43      boolean isOverrider(Symbol s) {
   26.44          if (s.kind != MTH || s.isStatic())
   26.45 @@ -1838,6 +1859,25 @@
   26.46          return false;
   26.47      }
   26.48  
   26.49 +    /** Is the annotation applicable to type annotations */
   26.50 +    boolean isTypeAnnotation(JCTypeAnnotation a, boolean isTypeParameter) {
   26.51 +        Attribute.Compound atTarget =
   26.52 +            a.annotationType.type.tsym.attribute(syms.annotationTargetType.tsym);
   26.53 +        if (atTarget == null) return true;
   26.54 +        Attribute atValue = atTarget.member(names.value);
   26.55 +        if (!(atValue instanceof Attribute.Array)) return true; // error recovery
   26.56 +        Attribute.Array arr = (Attribute.Array) atValue;
   26.57 +        for (Attribute app : arr.values) {
   26.58 +            if (!(app instanceof Attribute.Enum)) return true; // recovery
   26.59 +            Attribute.Enum e = (Attribute.Enum) app;
   26.60 +            if (!isTypeParameter && e.value.name == names.TYPE_USE)
   26.61 +                return true;
   26.62 +            else if (isTypeParameter && e.value.name == names.TYPE_PARAMETER)
   26.63 +                return true;
   26.64 +        }
   26.65 +        return false;
   26.66 +    }
   26.67 +
   26.68      /** Is the annotation applicable to the symbol? */
   26.69      boolean annotationApplicable(JCAnnotation a, Symbol s) {
   26.70          Attribute.Compound atTarget =
   26.71 @@ -1874,6 +1914,13 @@
   26.72                  }
   26.73              else if (e.value.name == names.PACKAGE)
   26.74                  { if (s.kind == PCK) return true; }
   26.75 +            else if (e.value.name == names.TYPE_USE)
   26.76 +                { if (s.kind == TYP ||
   26.77 +                      s.kind == VAR ||
   26.78 +                      (s.kind == MTH && !s.isConstructor() &&
   26.79 +                       s.type.getReturnType().tag != VOID))
   26.80 +                    return true;
   26.81 +                }
   26.82              else
   26.83                  return true; // recovery
   26.84          }

    27.1 --- a/src/share/classes/com/sun/tools/javac/comp/Flow.java	Fri Jun 26 10:26:27 2009 -0700
    27.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Flow.java	Sun Jun 28 00:01:09 2009 -0700
    27.3 @@ -1245,6 +1245,11 @@
    27.4          }
    27.5      }
    27.6  
    27.7 +    public void visitAnnotatedType(JCAnnotatedType tree) {
    27.8 +        // annotations don't get scanned
    27.9 +        tree.underlyingType.accept(this);
   27.10 +    }
   27.11 +
   27.12      public void visitIdent(JCIdent tree) {
   27.13          if (tree.sym.kind == VAR)
   27.14              checkInit(tree.pos(), (VarSymbol)tree.sym);
   27.15 @@ -1254,7 +1259,8 @@
   27.16          super.visitTypeCast(tree);
   27.17          if (!tree.type.isErroneous()
   27.18              && lint.isEnabled(Lint.LintCategory.CAST)
   27.19 -            && types.isSameType(tree.expr.type, tree.clazz.type)) {
   27.20 +            && types.isSameType(tree.expr.type, tree.clazz.type)
   27.21 +            && !(ignoreAnnotatedCasts && containsTypeAnnotation(tree.clazz))) {
   27.22              log.warning(tree.pos(), "redundant.cast", tree.expr.type);
   27.23          }
   27.24      }
   27.25 @@ -1264,6 +1270,23 @@
   27.26      }
   27.27  
   27.28  /**************************************************************************
   27.29 + * utility methods for ignoring type-annotated casts lint checking
   27.30 + *************************************************************************/
   27.31 +    private static final boolean ignoreAnnotatedCasts = true;
   27.32 +    private static class AnnotationFinder extends TreeScanner {
   27.33 +        public boolean foundTypeAnno = false;
   27.34 +        public void visitAnnotation(JCAnnotation tree) {
   27.35 +            foundTypeAnno = foundTypeAnno || (tree instanceof JCTypeAnnotation);
   27.36 +        }
   27.37 +    }
   27.38 +
   27.39 +    private boolean containsTypeAnnotation(JCTree e) {
   27.40 +        AnnotationFinder finder = new AnnotationFinder();
   27.41 +        finder.scan(e);
   27.42 +        return finder.foundTypeAnno;
   27.43 +    }
   27.44 +
   27.45 +/**************************************************************************
   27.46   * main method
   27.47   *************************************************************************/
   27.48  

    28.1 --- a/src/share/classes/com/sun/tools/javac/comp/Lower.java	Fri Jun 26 10:26:27 2009 -0700
    28.2 +++ b/src/share/classes/com/sun/tools/javac/comp/Lower.java	Sun Jun 28 00:01:09 2009 -0700
    28.3 @@ -1979,7 +1979,6 @@
    28.4              c.members_field = new Scope(c);
    28.5              c.flags_field = flags;
    28.6              c.attributes_field = tree.packge.attributes_field;
    28.7 -            tree.packge.attributes_field = List.nil();
    28.8              ClassType ctype = (ClassType) c.type;
    28.9              ctype.supertype_field = syms.objectType;
   28.10              ctype.interfaces_field = List.nil();
   28.11 @@ -2369,6 +2368,11 @@
   28.12          result = tree;
   28.13      }
   28.14  
   28.15 +    public void visitAnnotatedType(JCAnnotatedType tree) {
   28.16 +        tree.underlyingType = translate(tree.underlyingType);
   28.17 +        result = tree.underlyingType;
   28.18 +    }
   28.19 +
   28.20      public void visitTypeCast(JCTypeCast tree) {
   28.21          tree.clazz = translate(tree.clazz);
   28.22          if (tree.type.isPrimitive() != tree.expr.type.isPrimitive())

    29.1 --- a/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Fri Jun 26 10:26:27 2009 -0700
    29.2 +++ b/src/share/classes/com/sun/tools/javac/comp/MemberEnter.java	Sun Jun 28 00:01:09 2009 -0700
    29.3 @@ -99,8 +99,8 @@
    29.4          types = Types.instance(context);
    29.5          diags = JCDiagnostic.Factory.instance(context);
    29.6          target = Target.instance(context);
    29.7 -        skipAnnotations =
    29.8 -            Options.instance(context).get("skipAnnotations") != null;
    29.9 +        Options options = Options.instance(context);
   29.10 +        skipAnnotations = options.get("skipAnnotations") != null;
   29.11      }
   29.12  
   29.13      /** A queue for classes whose members still need to be entered into the
   29.14 @@ -906,6 +906,10 @@
   29.15              if (hasDeprecatedAnnotation(tree.mods.annotations))
   29.16                  c.flags_field |= DEPRECATED;
   29.17              annotateLater(tree.mods.annotations, baseEnv, c);
   29.18 +            // class type parameters use baseEnv but everything uses env
   29.19 +            for (JCTypeParameter tp : tree.typarams)
   29.20 +                tp.accept(new TypeAnnotate(baseEnv));
   29.21 +            tree.accept(new TypeAnnotate(env));
   29.22  
   29.23              chk.checkNonCyclic(tree.pos(), c.type);
   29.24  
   29.25 @@ -988,6 +992,100 @@
   29.26          }
   29.27      }
   29.28  
   29.29 +    // A sub-phase that "compiles" annotations in annotated types.
   29.30 +    private class TypeAnnotate extends TreeScanner {
   29.31 +        private Env<AttrContext> env;
   29.32 +        public TypeAnnotate(Env<AttrContext> env) { this.env = env; }
   29.33 +
   29.34 +        private void enterTypeAnnotations(List<JCTypeAnnotation> annotations) {
   29.35 +            Set<TypeSymbol> annotated = new HashSet<TypeSymbol>();
   29.36 +            if (!skipAnnotations)
   29.37 +                for (List<JCTypeAnnotation> al = annotations; al.nonEmpty(); al = al.tail) {
   29.38 +                    JCTypeAnnotation a = al.head;
   29.39 +                    Attribute.Compound c = annotate.enterAnnotation(a,
   29.40 +                            syms.annotationType,
   29.41 +                            env);
   29.42 +                    if (c == null) continue;
   29.43 +                    Attribute.TypeCompound tc = new Attribute.TypeCompound(c.type, c.values, a.annotation_position);
   29.44 +                    a.attribute_field = tc;
   29.45 +                    // Note: @Deprecated has no effect on local variables and parameters
   29.46 +                    if (!annotated.add(a.type.tsym))
   29.47 +                        log.error(a.pos, "duplicate.annotation");
   29.48 +                }
   29.49 +        }
   29.50 +
   29.51 +        // each class (including enclosed inner classes) should be visited
   29.52 +        // separately through MemberEnter.complete(Symbol)
   29.53 +        // this flag is used to prevent from visiting inner classes.
   29.54 +        private boolean isEnclosingClass = false;
   29.55 +        @Override
   29.56 +        public void visitClassDef(final JCClassDecl tree) {
   29.57 +            if (isEnclosingClass)
   29.58 +                return;
   29.59 +            isEnclosingClass = true;
   29.60 +            scan(tree.mods);
   29.61 +            // type parameter need to be visited with a separate env
   29.62 +            // scan(tree.typarams);
   29.63 +            scan(tree.extending);
   29.64 +            scan(tree.implementing);
   29.65 +            scan(tree.defs);
   29.66 +        }
   29.67 +
   29.68 +        private void annotate(final JCTree tree, final List<JCTypeAnnotation> annotations) {
   29.69 +            annotate.later(new Annotate.Annotator() {
   29.70 +                public String toString() {
   29.71 +                    return "annotate " + annotations + " onto " + tree;
   29.72 +                }
   29.73 +                public void enterAnnotation() {
   29.74 +                    JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
   29.75 +                    try {
   29.76 +                        enterTypeAnnotations(annotations);
   29.77 +
   29.78 +                        // enrich type parameter symbols... easier for annotation processors
   29.79 +                        if (tree instanceof JCTypeParameter) {
   29.80 +                            JCTypeParameter typeparam = (JCTypeParameter)tree;
   29.81 +                            ListBuffer<Attribute.Compound> buf = ListBuffer.lb();
   29.82 +                            for (JCTypeAnnotation anno : annotations)
   29.83 +                                buf.add(anno.attribute_field);
   29.84 +                            typeparam.type.tsym.attributes_field = buf.toList();
   29.85 +                        }
   29.86 +                    } finally {
   29.87 +                        log.useSource(prev);
   29.88 +                    }
   29.89 +                }
   29.90 +            });
   29.91 +        }
   29.92 +
   29.93 +        @Override
   29.94 +        public void visitAnnotatedType(final JCAnnotatedType tree) {
   29.95 +            annotate(tree, tree.annotations);
   29.96 +            super.visitAnnotatedType(tree);
   29.97 +        }
   29.98 +        @Override
   29.99 +        public void visitTypeParameter(final JCTypeParameter tree) {
  29.100 +            annotate(tree, tree.annotations);
  29.101 +            super.visitTypeParameter(tree);
  29.102 +        }
  29.103 +        @Override
  29.104 +        public void visitNewArray(final JCNewArray tree) {
  29.105 +            annotate(tree, tree.annotations);
  29.106 +            for (List<JCTypeAnnotation> dimAnnos : tree.dimAnnotations)
  29.107 +                annotate(tree, dimAnnos);
  29.108 +            super.visitNewArray(tree);
  29.109 +        }
  29.110 +        @Override
  29.111 +        public void visitApply(JCMethodInvocation tree) {
  29.112 +            super.visitApply(tree);
  29.113 +            scan(tree.typeargs);
  29.114 +        }
  29.115 +        @Override
  29.116 +        public void visitMethodDef(JCMethodDecl tree) {
  29.117 +            annotate(tree, tree.receiverAnnotations);
  29.118 +            super.visitMethodDef(tree);
  29.119 +        }
  29.120 +    }
  29.121 +
  29.122 +
  29.123      private Env<AttrContext> baseEnv(JCClassDecl tree, Env<AttrContext> env) {
  29.124          Scope typaramScope = new Scope(tree.sym);
  29.125          if (tree.typarams != null)

    30.1 --- a/src/share/classes/com/sun/tools/javac/comp/TransTypes.java	Fri Jun 26 10:26:27 2009 -0700
    30.2 +++ b/src/share/classes/com/sun/tools/javac/comp/TransTypes.java	Sun Jun 28 00:01:09 2009 -0700
    30.3 @@ -27,6 +27,8 @@
    30.4  
    30.5  import java.util.*;
    30.6  
    30.7 +import javax.lang.model.element.ElementKind;
    30.8 +
    30.9  import com.sun.tools.javac.code.*;
   30.10  import com.sun.tools.javac.code.Symbol.*;
   30.11  import com.sun.tools.javac.tree.*;
   30.12 @@ -59,6 +61,8 @@
   30.13          return instance;
   30.14      }
   30.15  
   30.16 +    private boolean debugJSR308;
   30.17 +
   30.18      private Names names;
   30.19      private Log log;
   30.20      private Symtab syms;
   30.21 @@ -88,6 +92,7 @@
   30.22          types = Types.instance(context);
   30.23          make = TreeMaker.instance(context);
   30.24          resolve = Resolve.instance(context);
   30.25 +        debugJSR308 = Options.instance(context).get("TA:trans") != null;
   30.26      }
   30.27  
   30.28      /** A hashtable mapping bridge methods to the methods they override after
   30.29 @@ -435,12 +440,15 @@
   30.30      }
   30.31  
   30.32      public void visitClassDef(JCClassDecl tree) {
   30.33 +        new TypeAnnotationPositions().scan(tree);
   30.34 +        new TypeAnnotationLift().scan(tree);
   30.35          translateClass(tree.sym);
   30.36          result = tree;
   30.37      }
   30.38  
   30.39      JCMethodDecl currentMethod = null;
   30.40      public void visitMethodDef(JCMethodDecl tree) {
   30.41 +        tree.sym.typeAnnotations = tree.sym.typeAnnotations;
   30.42          JCMethodDecl previousMethod = currentMethod;
   30.43          try {
   30.44              currentMethod = tree;
   30.45 @@ -726,8 +734,8 @@
   30.46      /** Visitor method for parameterized types.
   30.47       */
   30.48      public void visitTypeApply(JCTypeApply tree) {
   30.49 -        // Delete all type parameters.
   30.50 -        result = translate(tree.clazz, null);
   30.51 +        JCTree clazz = translate(tree.clazz, null);
   30.52 +        result = clazz;
   30.53      }
   30.54  
   30.55  /**************************************************************************
   30.56 @@ -793,4 +801,342 @@
   30.57          pt = null;
   30.58          return translate(cdef, null);
   30.59      }
   30.60 +
   30.61 +    private class TypeAnnotationPositions extends TreeScanner {
   30.62 +
   30.63 +        private ListBuffer<JCTree> frames = ListBuffer.lb();
   30.64 +        private void push(JCTree t) { frames = frames.prepend(t); }
   30.65 +        private JCTree pop() { return frames.next(); }
   30.66 +        private JCTree peek() { return frames.first(); }
   30.67 +        private JCTree peek2() { return frames.toList().tail.head; }
   30.68 +
   30.69 +        @Override
   30.70 +        public void scan(JCTree tree) {
   30.71 +            push(tree);
   30.72 +            super.scan(tree);
   30.73 +            pop();
   30.74 +        }
   30.75 +
   30.76 +        private TypeAnnotationPosition resolveFrame(JCTree tree, JCTree frame,
   30.77 +                List<JCTree> path, TypeAnnotationPosition p) {
   30.78 +            switch (frame.getKind()) {
   30.79 +                case TYPE_CAST:
   30.80 +                    p.type = TargetType.TYPECAST;
   30.81 +                    p.pos = frame.pos;
   30.82 +                    return p;
   30.83 +
   30.84 +                case INSTANCE_OF:
   30.85 +                    p.type = TargetType.INSTANCEOF;
   30.86 +                    p.pos = frame.pos;
   30.87 +                    return p;
   30.88 +
   30.89 +                case NEW_CLASS:
   30.90 +                    p.type = TargetType.NEW;
   30.91 +                    p.pos = frame.pos;
   30.92 +                    return p;
   30.93 +
   30.94 +                case NEW_ARRAY:
   30.95 +                    p.type = TargetType.NEW;
   30.96 +                    p.pos = frame.pos;
   30.97 +                    return p;
   30.98 +
   30.99 +                case CLASS:
  30.100 +                    p.pos = frame.pos;
  30.101 +                    if (((JCClassDecl)frame).extending == tree) {
  30.102 +                        p.type = TargetType.CLASS_EXTENDS;
  30.103 +                        p.type_index = -1;
  30.104 +                    } else if (((JCClassDecl)frame).implementing.contains(tree)) {
  30.105 +                        p.type = TargetType.CLASS_EXTENDS;
  30.106 +                        p.type_index = ((JCClassDecl)frame).implementing.indexOf(tree);
  30.107 +                    } else if (((JCClassDecl)frame).typarams.contains(tree)) {
  30.108 +                        p.type = TargetType.CLASS_TYPE_PARAMETER;
  30.109 +                        p.parameter_index = ((JCClassDecl)frame).typarams.indexOf(tree);
  30.110 +                    } else
  30.111 +                        throw new AssertionError();
  30.112 +                    return p;
  30.113 +
  30.114 +                case METHOD: {
  30.115 +                    JCMethodDecl frameMethod = (JCMethodDecl)frame;
  30.116 +                    p.pos = frame.pos;
  30.117 +                    if (frameMethod.receiverAnnotations.contains(tree))
  30.118 +                        p.type = TargetType.METHOD_RECEIVER;
  30.119 +                    else if (frameMethod.thrown.contains(tree)) {
  30.120 +                        p.type = TargetType.THROWS;
  30.121 +                        p.type_index = frameMethod.thrown.indexOf(tree);
  30.122 +                    } else if (((JCMethodDecl)frame).restype == tree) {
  30.123 +                        p.type = TargetType.METHOD_RETURN_GENERIC_OR_ARRAY;
  30.124 +                    } else if (frameMethod.typarams.contains(tree)) {
  30.125 +                        p.type = TargetType.METHOD_TYPE_PARAMETER;
  30.126 +                        p.parameter_index = frameMethod.typarams.indexOf(tree);
  30.127 +                    } else
  30.128 +                        throw new AssertionError();
  30.129 +                    return p;
  30.130 +                }
  30.131 +                case MEMBER_SELECT: {
  30.132 +                    JCFieldAccess fieldFrame = (JCFieldAccess)frame;
  30.133 +                    if (fieldFrame.name == names._class) {
  30.134 +                        p.type = TargetType.CLASS_LITERAL;
  30.135 +                        if (fieldFrame.selected instanceof JCAnnotatedType) {
  30.136 +                            p.pos = TreeInfo.typeIn(fieldFrame).pos;
  30.137 +                        } else if (fieldFrame.selected instanceof JCArrayTypeTree) {
  30.138 +                            p.pos = fieldFrame.selected.pos;
  30.139 +                        }
  30.140 +                    } else
  30.141 +                        throw new AssertionError();
  30.142 +                    return p;
  30.143 +                }
  30.144 +                case PARAMETERIZED_TYPE: {
  30.145 +                    TypeAnnotationPosition nextP;
  30.146 +                    if (((JCTypeApply)frame).clazz == tree)
  30.147 +                        nextP = p; // generic: RAW; noop
  30.148 +                    else if (((JCTypeApply)frame).arguments.contains(tree))
  30.149 +                        p.location = p.location.prepend(
  30.150 +                                ((JCTypeApply)frame).arguments.indexOf(tree));
  30.151 +                    else
  30.152 +                        throw new AssertionError();
  30.153 +
  30.154 +                    List<JCTree> newPath = path.tail;
  30.155 +                    return resolveFrame(newPath.head, newPath.tail.head, newPath, p);
  30.156 +                }
  30.157 +
  30.158 +                case ARRAY_TYPE: {
  30.159 +                    p.location = p.location.prepend(0);
  30.160 +                    List<JCTree> newPath = path.tail;
  30.161 +                    return resolveFrame(newPath.head, newPath.tail.head, newPath, p);
  30.162 +                }
  30.163 +
  30.164 +                case TYPE_PARAMETER:
  30.165 +                    if (path.tail.tail.head.getTag() == JCTree.CLASSDEF) {
  30.166 +                        JCClassDecl clazz = (JCClassDecl)path.tail.tail.head;
  30.167 +                        p.type = TargetType.CLASS_TYPE_PARAMETER_BOUND;
  30.168 +                        p.parameter_index = clazz.typarams.indexOf(path.tail.head);
  30.169 +                        p.bound_index = ((JCTypeParameter)frame).bounds.indexOf(tree);
  30.170 +                    } else if (path.tail.tail.head.getTag() == JCTree.METHODDEF) {
  30.171 +                        JCMethodDecl method = (JCMethodDecl)path.tail.tail.head;
  30.172 +                        p.type = TargetType.METHOD_TYPE_PARAMETER_BOUND;
  30.173 +                        p.parameter_index = method.typarams.indexOf(path.tail.head);
  30.174 +                        p.bound_index = ((JCTypeParameter)frame).bounds.indexOf(tree);
  30.175 +                    } else
  30.176 +                        throw new AssertionError();
  30.177 +                    p.pos = frame.pos;
  30.178 +                    return p;
  30.179 +
  30.180 +                case VARIABLE:
  30.181 +                    VarSymbol v = ((JCVariableDecl)frame).sym;
  30.182 +                    p.pos = frame.pos;
  30.183 +                    switch (v.getKind()) {
  30.184 +                        case LOCAL_VARIABLE:
  30.185 +                            p.type = TargetType.LOCAL_VARIABLE; break;
  30.186 +                        case FIELD:
  30.187 +                            p.type = TargetType.FIELD_GENERIC_OR_ARRAY; break;
  30.188 +                        case PARAMETER:
  30.189 +                            p.type = TargetType.METHOD_PARAMETER_GENERIC_OR_ARRAY;
  30.190 +                            p.parameter_index = methodParamIndex(path, frame);
  30.191 +                            break;
  30.192 +                        default: throw new AssertionError();
  30.193 +                    }
  30.194 +                    return p;
  30.195 +
  30.196 +                case ANNOTATED_TYPE: {
  30.197 +                    List<JCTree> newPath = path.tail;
  30.198 +                    return resolveFrame(newPath.head, newPath.tail.head,
  30.199 +                            newPath, p);
  30.200 +                }
  30.201 +
  30.202 +                case METHOD_INVOCATION: {
  30.203 +                    JCMethodInvocation invocation = (JCMethodInvocation)frame;
  30.204 +                    if (!invocation.typeargs.contains(tree))
  30.205 +                        throw new AssertionError("{" + tree + "} is not an argument in the invocation: " + invocation);
  30.206 +                    p.type = TargetType.METHOD_TYPE_ARGUMENT;
  30.207 +                    p.pos = invocation.pos;
  30.208 +                    p.type_index = invocation.typeargs.indexOf(tree);
  30.209 +                    return p;
  30.210 +                }
  30.211 +
  30.212 +                case EXTENDS_WILDCARD:
  30.213 +                case SUPER_WILDCARD: {
  30.214 +                    p.type = TargetType.WILDCARD_BOUND;
  30.215 +                    List<JCTree> newPath = path.tail;
  30.216 +
  30.217 +                    TypeAnnotationPosition wildcard =
  30.218 +                        resolveFrame(newPath.head, newPath.tail.head, newPath,
  30.219 +                                new TypeAnnotationPosition());
  30.220 +                    if (!wildcard.location.isEmpty())
  30.221 +                        wildcard.type = wildcard.type.getGenericComplement();
  30.222 +                    p.wildcard_position = wildcard;
  30.223 +                    p.pos = frame.pos;
  30.224 +                    return p;
  30.225 +                }
  30.226 +            }
  30.227 +            return p;
  30.228 +        }
  30.229 +
  30.230 +        @Override
  30.231 +        public void visitApply(JCMethodInvocation tree) {
  30.232 +            scan(tree.meth);
  30.233 +            scan(tree.typeargs);
  30.234 +            scan(tree.args);
  30.235 +        }
  30.236 +
  30.237 +        private void setTypeAnnotationPos(List<JCTypeAnnotation> annotations, TypeAnnotationPosition position) {
  30.238 +            for (JCTypeAnnotation anno : annotations) {
  30.239 +                anno.annotation_position = position;
  30.240 +                anno.attribute_field.position = position;
  30.241 +            }
  30.242 +        }
  30.243 +
  30.244 +        @Override
  30.245 +        public void visitNewArray(JCNewArray tree) {
  30.246 +            findPosition(tree, tree, tree.annotations);
  30.247 +            int dimAnnosCount = tree.dimAnnotations.size();
  30.248 +
  30.249 +            // handle annotations associated with dimentions
  30.250 +            for (int i = 0; i < dimAnnosCount; ++i) {
  30.251 +                TypeAnnotationPosition p = new TypeAnnotationPosition();
  30.252 +                p.type = TargetType.NEW_GENERIC_OR_ARRAY;
  30.253 +                p.pos = tree.pos;
  30.254 +                p.location = p.location.append(i);
  30.255 +                setTypeAnnotationPos(tree.dimAnnotations.get(i), p);
  30.256 +            }
  30.257 +
  30.258 +            // handle "free" annotations
  30.259 +            int i = dimAnnosCount == 0 ? 0 : dimAnnosCount - 1;
  30.260 +            JCExpression elemType = tree.elemtype;
  30.261 +            while (elemType != null) {
  30.262 +                if (elemType.getTag() == JCTree.ANNOTATED_TYPE) {
  30.263 +                    JCAnnotatedType at = (JCAnnotatedType)elemType;
  30.264 +                    TypeAnnotationPosition p = new TypeAnnotationPosition();
  30.265 +                    p.type = TargetType.NEW_GENERIC_OR_ARRAY;
  30.266 +                    p.pos = tree.pos;
  30.267 +                    p.location = p.location.append(i);
  30.268 +                    setTypeAnnotationPos(at.annotations, p);
  30.269 +                    elemType = at.underlyingType;
  30.270 +                } else if (elemType.getTag() == JCTree.TYPEARRAY) {
  30.271 +                    ++i;
  30.272 +                    elemType = ((JCArrayTypeTree)elemType).elemtype;
  30.273 +                } else
  30.274 +                    break;
  30.275 +            }
  30.276 +
  30.277 +            // find annotations locations of initializer elements
  30.278 +            scan(tree.elems);
  30.279 +        }
  30.280 +
  30.281 +        @Override
  30.282 +        public void visitAnnotatedType(JCAnnotatedType tree) {
  30.283 +            findPosition(tree, peek2(), tree.annotations);
  30.284 +            super.visitAnnotatedType(tree);
  30.285 +        }
  30.286 +
  30.287 +        @Override
  30.288 +        public void visitMethodDef(JCMethodDecl tree) {
  30.289 +            TypeAnnotationPosition p = new TypeAnnotationPosition();
  30.290 +            p.type = TargetType.METHOD_RECEIVER;
  30.291 +            setTypeAnnotationPos(tree.receiverAnnotations, p);
  30.292 +            super.visitMethodDef(tree);
  30.293 +        }
  30.294 +        @Override
  30.295 +        public void visitTypeParameter(JCTypeParameter tree) {
  30.296 +            findPosition(tree, peek2(), tree.annotations);
  30.297 +            super.visitTypeParameter(tree);
  30.298 +        }
  30.299 +
  30.300 +        void findPosition(JCTree tree, JCTree frame, List<JCTypeAnnotation> annotations) {
  30.301 +            if (!annotations.isEmpty()) {
  30.302 +                TypeAnnotationPosition p =
  30.303 +                        resolveFrame(tree, frame, frames.toList(),
  30.304 +                                new TypeAnnotationPosition());
  30.305 +                if (!p.location.isEmpty())
  30.306 +                    p.type = p.type.getGenericComplement();
  30.307 +                setTypeAnnotationPos(annotations, p);
  30.308 +                if (debugJSR308) {
  30.309 +                    System.out.println("trans: " + tree);
  30.310 +                    System.out.println("  target: " + p);
  30.311 +                }
  30.312 +            }
  30.313 +        }
  30.314 +
  30.315 +        private int methodParamIndex(List<JCTree> path, JCTree param) {
  30.316 +            List<JCTree> curr = path;
  30.317 +            if (curr.head != param)
  30.318 +                curr = path.tail;
  30.319 +            JCMethodDecl method = (JCMethodDecl)curr.tail.head;
  30.320 +            return method.params.indexOf(param);
  30.321 +        }
  30.322 +    }
  30.323 +
  30.324 +    private class TypeAnnotationLift extends TreeScanner {
  30.325 +        List<Attribute.TypeCompound> recordedTypeAnnotations = List.nil();
  30.326 +
  30.327 +        boolean isInner = false;
  30.328 +        @Override
  30.329 +        public void visitClassDef(JCClassDecl tree) {
  30.330 +            if (isInner) {
  30.331 +                // tree is an inner class tree.  stop now.
  30.332 +                // TransTypes.visitClassDef makes an invocation for each class
  30.333 +                // seperately.
  30.334 +                return;
  30.335 +            }
  30.336 +            isInner = true;
  30.337 +            List<Attribute.TypeCompound> prevTAs = recordedTypeAnnotations;
  30.338 +            recordedTypeAnnotations = List.nil();
  30.339 +            try {
  30.340 +                super.visitClassDef(tree);
  30.341 +            } finally {
  30.342 +                tree.sym.typeAnnotations = tree.sym.typeAnnotations.appendList(recordedTypeAnnotations);
  30.343 +                recordedTypeAnnotations = prevTAs;
  30.344 +            }
  30.345 +        }
  30.346 +
  30.347 +        @Override
  30.348 +        public void visitMethodDef(JCMethodDecl tree) {
  30.349 +            List<Attribute.TypeCompound> prevTAs = recordedTypeAnnotations;
  30.350 +            recordedTypeAnnotations = List.nil();
  30.351 +            try {
  30.352 +                super.visitMethodDef(tree);
  30.353 +            } finally {
  30.354 +                tree.sym.typeAnnotations = tree.sym.typeAnnotations.appendList(recordedTypeAnnotations);
  30.355 +                recordedTypeAnnotations = prevTAs;
  30.356 +            }
  30.357 +        }
  30.358 +
  30.359 +        @Override
  30.360 +        public void visitVarDef(JCVariableDecl tree) {
  30.361 +            List<Attribute.TypeCompound> prevTAs = recordedTypeAnnotations;
  30.362 +            recordedTypeAnnotations = List.nil();
  30.363 +            ElementKind kind = tree.sym.getKind();
  30.364 +            if (kind == ElementKind.LOCAL_VARIABLE && tree.mods.annotations.nonEmpty()) {
  30.365 +                // need to lift the annotations
  30.366 +                TypeAnnotationPosition position = new TypeAnnotationPosition();
  30.367 +                position.pos = tree.pos;
  30.368 +                position.type = TargetType.LOCAL_VARIABLE;
  30.369 +                for (Attribute.Compound attribute : tree.sym.attributes_field) {
  30.370 +                    Attribute.TypeCompound tc =
  30.371 +                        new Attribute.TypeCompound(attribute.type, attribute.values, position);
  30.372 +                    recordedTypeAnnotations = recordedTypeAnnotations.append(tc);
  30.373 +                }
  30.374 +            }
  30.375 +            try {
  30.376 +                super.visitVarDef(tree);
  30.377 +            } finally {
  30.378 +                if (kind.isField() || kind == ElementKind.LOCAL_VARIABLE)
  30.379 +                    tree.sym.typeAnnotations = tree.sym.typeAnnotations.appendList(recordedTypeAnnotations);
  30.380 +                recordedTypeAnnotations = kind.isField() ? prevTAs : prevTAs.appendList(recordedTypeAnnotations);
  30.381 +            }
  30.382 +        }
  30.383 +
  30.384 +        @Override
  30.385 +        public void visitApply(JCMethodInvocation tree) {
  30.386 +            scan(tree.meth);
  30.387 +            scan(tree.typeargs);
  30.388 +            scan(tree.args);
  30.389 +        }
  30.390 +
  30.391 +        public void visitAnnotation(JCAnnotation tree) {
  30.392 +            if (tree instanceof JCTypeAnnotation)
  30.393 +                recordedTypeAnnotations = recordedTypeAnnotations.append(((JCTypeAnnotation)tree).attribute_field);
  30.394 +            super.visitAnnotation(tree);
  30.395 +        }
  30.396 +    }
  30.397 +
  30.398  }

    31.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Fri Jun 26 10:26:27 2009 -0700
    31.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Sun Jun 28 00:01:09 2009 -0700
    31.3 @@ -47,7 +47,6 @@
    31.4  import com.sun.tools.javac.code.Symtab;
    31.5  import com.sun.tools.javac.file.BaseFileObject;
    31.6  import com.sun.tools.javac.util.*;
    31.7 -import com.sun.tools.javac.util.List;
    31.8  
    31.9  import static com.sun.tools.javac.code.Flags.*;
   31.10  import static com.sun.tools.javac.code.Kinds.*;
   31.11 @@ -187,6 +186,10 @@
   31.12      /** The minor version number of the class file being read. */
   31.13      int minorVersion;
   31.14  
   31.15 +    /** Switch: debug output for JSR 308-related operations.
   31.16 +     */
   31.17 +    boolean debugJSR308;
   31.18 +
   31.19      /** Get the ClassReader instance for this invocation. */
   31.20      public static ClassReader instance(Context context) {
   31.21          ClassReader instance = context.get(classReaderKey);
   31.22 @@ -256,6 +259,7 @@
   31.23              : null;
   31.24  
   31.25          typevars = new Scope(syms.noSymbol);
   31.26 +        debugJSR308 = options.get("TA:reader") != null;
   31.27  
   31.28          initAttributeReaders();
   31.29      }
   31.30 @@ -303,6 +307,12 @@
   31.31          return (char)(((buf[bp++] & 0xFF) << 8) + (buf[bp++] & 0xFF));
   31.32      }
   31.33  
   31.34 +    /** Read a byte.
   31.35 +     */
   31.36 +    byte nextByte() {
   31.37 +        return buf[bp++];
   31.38 +    }
   31.39 +
   31.40      /** Read an integer.
   31.41       */
   31.42      int nextInt() {
   31.43 @@ -1060,7 +1070,21 @@
   31.44                      if (allowVarargs)
   31.45                          sym.flags_field |= VARARGS;
   31.46                  }
   31.47 -            }
   31.48 +            },
   31.49 +
   31.50 +            // v51 attributes
   31.51 +            new AttributeReader(names.RuntimeVisibleTypeAnnotations, V51, CLASS_OR_MEMBER_ATTRIBUTE) {
   31.52 +                void read(Symbol sym, int attrLen) {
   31.53 +                    attachTypeAnnotations(sym);
   31.54 +                }
   31.55 +            },
   31.56 +
   31.57 +            new AttributeReader(names.RuntimeInvisibleTypeAnnotations, V51, CLASS_OR_MEMBER_ATTRIBUTE) {
   31.58 +                void read(Symbol sym, int attrLen) {
   31.59 +                    attachTypeAnnotations(sym);
   31.60 +                }
   31.61 +            },
   31.62 +
   31.63  
   31.64              // The following attributes for a Code attribute are not currently handled
   31.65              // StackMapTable
   31.66 @@ -1268,6 +1292,17 @@
   31.67          }
   31.68      }
   31.69  
   31.70 +    void attachTypeAnnotations(final Symbol sym) {
   31.71 +        int numAttributes = nextChar();
   31.72 +        if (numAttributes != 0) {
   31.73 +            ListBuffer<TypeAnnotationProxy> proxies =
   31.74 +                ListBuffer.lb();
   31.75 +            for (int i = 0; i < numAttributes; i++)
   31.76 +                proxies.append(readTypeAnnotation());
   31.77 +            annotate.later(new TypeAnnotationCompleter(sym, proxies.toList()));
   31.78 +        }
   31.79 +    }
   31.80 +
   31.81      /** Attach the default value for an annotation element.
   31.82       */
   31.83      void attachAnnotationDefault(final Symbol sym) {
   31.84 @@ -1304,6 +1339,121 @@
   31.85          return new CompoundAnnotationProxy(t, pairs.toList());
   31.86      }
   31.87  
   31.88 +    TypeAnnotationProxy readTypeAnnotation() {
   31.89 +        CompoundAnnotationProxy proxy = readCompoundAnnotation();
   31.90 +        TypeAnnotationPosition position = readPosition();
   31.91 +
   31.92 +        if (debugJSR308)
   31.93 +            System.out.println("TA: reading: " + proxy + " @ " + position
   31.94 +                    + " in " + log.currentSourceFile());
   31.95 +
   31.96 +        return new TypeAnnotationProxy(proxy, position);
   31.97 +    }
   31.98 +
   31.99 +    TypeAnnotationPosition readPosition() {
  31.100 +        byte tag = nextByte();
  31.101 +
  31.102 +        if (!TargetType.isValidTargetTypeValue(tag))
  31.103 +            throw this.badClassFile("bad.type.annotation.value", tag);
  31.104 +
  31.105 +        TypeAnnotationPosition position = new TypeAnnotationPosition();
  31.106 +        TargetType type = TargetType.fromTargetTypeValue(tag);
  31.107 +
  31.108 +        position.type = type;
  31.109 +
  31.110 +        switch (type) {
  31.111 +        // type case
  31.112 +        case TYPECAST:
  31.113 +        case TYPECAST_GENERIC_OR_ARRAY:
  31.114 +        // object creation
  31.115 +        case INSTANCEOF:
  31.116 +        case INSTANCEOF_GENERIC_OR_ARRAY:
  31.117 +        // new expression
  31.118 +        case NEW:
  31.119 +        case NEW_GENERIC_OR_ARRAY:
  31.120 +            position.offset = nextChar();
  31.121 +            break;
  31.122 +         // local variable
  31.123 +        case LOCAL_VARIABLE:
  31.124 +        case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
  31.125 +            int table_length = nextChar();
  31.126 +            position.lvarOffset = new int[table_length];
  31.127 +            position.lvarLength = new int[table_length];
  31.128 +            position.lvarIndex = new int[table_length];
  31.129 +
  31.130 +            for (int i = 0; i < table_length; ++i) {
  31.131 +                position.lvarOffset[i] = nextChar();
  31.132 +                position.lvarLength[i] = nextChar();
  31.133 +                position.lvarIndex[i] = nextChar();
  31.134 +            }
  31.135 +            break;
  31.136 +         // method receiver
  31.137 +        case METHOD_RECEIVER:
  31.138 +            // Do nothing
  31.139 +            break;
  31.140 +        // type parameters
  31.141 +        case CLASS_TYPE_PARAMETER:
  31.142 +        case METHOD_TYPE_PARAMETER:
  31.143 +            position.parameter_index = nextByte();
  31.144 +            break;
  31.145 +        // type parameter bounds
  31.146 +        case CLASS_TYPE_PARAMETER_BOUND:
  31.147 +        case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  31.148 +        case METHOD_TYPE_PARAMETER_BOUND:
  31.149 +        case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  31.150 +            position.parameter_index = nextByte();
  31.151 +            position.bound_index = nextByte();
  31.152 +            break;
  31.153 +         // wildcard
  31.154 +        case WILDCARD_BOUND:
  31.155 +        case WILDCARD_BOUND_GENERIC_OR_ARRAY:
  31.156 +            position.wildcard_position = readPosition();
  31.157 +            break;
  31.158 +         // Class extends and implements clauses
  31.159 +        case CLASS_EXTENDS:
  31.160 +        case CLASS_EXTENDS_GENERIC_OR_ARRAY:
  31.161 +            position.type_index = nextByte();
  31.162 +            break;
  31.163 +        // throws
  31.164 +        case THROWS:
  31.165 +            position.type_index = nextByte();
  31.166 +            break;
  31.167 +        case CLASS_LITERAL:
  31.168 +        case CLASS_LITERAL_GENERIC_OR_ARRAY:
  31.169 +            position.offset = nextChar();
  31.170 +            break;
  31.171 +        // method parameter: not specified
  31.172 +        case METHOD_PARAMETER_GENERIC_OR_ARRAY:
  31.173 +            position.parameter_index = nextByte();
  31.174 +            break;
  31.175 +        // method type argument: wasn't specified
  31.176 +        case NEW_TYPE_ARGUMENT:
  31.177 +        case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  31.178 +        case METHOD_TYPE_ARGUMENT:
  31.179 +        case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  31.180 +            position.offset = nextChar();
  31.181 +            position.type_index = nextByte();
  31.182 +            break;
  31.183 +        // We don't need to worry abut these
  31.184 +        case METHOD_RETURN_GENERIC_OR_ARRAY:
  31.185 +        case FIELD_GENERIC_OR_ARRAY:
  31.186 +            break;
  31.187 +        case UNKNOWN:
  31.188 +            break;
  31.189 +        default:
  31.190 +            throw new AssertionError("unknown type: " + position);
  31.191 +        }
  31.192 +
  31.193 +        if (type.hasLocation()) {
  31.194 +            int len = nextChar();
  31.195 +            ListBuffer<Integer> loc = ListBuffer.lb();
  31.196 +            for (int i = 0; i < len; i++)
  31.197 +                loc = loc.append((int)nextByte());
  31.198 +            position.location = loc.toList();
  31.199 +        }
  31.200 +
  31.201 +        return position;
  31.202 +    }
  31.203      Attribute readAttributeValue() {
  31.204          char c = (char) buf[bp++];
  31.205          switch (c) {
  31.206 @@ -1408,6 +1558,18 @@
  31.207          }
  31.208      }
  31.209  
  31.210 +    /** A temporary proxy representing a type annotation.
  31.211 +     */
  31.212 +    static class TypeAnnotationProxy {
  31.213 +        final CompoundAnnotationProxy compound;
  31.214 +        final TypeAnnotationPosition position;
  31.215 +        public TypeAnnotationProxy(CompoundAnnotationProxy compound,
  31.216 +                TypeAnnotationPosition position) {
  31.217 +            this.compound = compound;
  31.218 +            this.position = position;
  31.219 +        }
  31.220 +    }
  31.221 +
  31.222      class AnnotationDeproxy implements ProxyVisitor {
  31.223          private ClassSymbol requestingOwner = currentOwner.kind == MTH
  31.224              ? currentOwner.enclClass() : (ClassSymbol)currentOwner;
  31.225 @@ -1604,6 +1766,45 @@
  31.226          }
  31.227      }
  31.228  
  31.229 +    class TypeAnnotationCompleter extends AnnotationCompleter {
  31.230 +
  31.231 +        List<TypeAnnotationProxy> proxies;
  31.232 +
  31.233 +        TypeAnnotationCompleter(Symbol sym,
  31.234 +                List<TypeAnnotationProxy> proxies) {
  31.235 +            super(sym, List.<CompoundAnnotationProxy>nil());
  31.236 +            this.proxies = proxies;
  31.237 +        }
  31.238 +
  31.239 +        List<Attribute.TypeCompound> deproxyTypeCompoundList(List<TypeAnnotationProxy> proxies) {
  31.240 +            ListBuffer<Attribute.TypeCompound> buf = ListBuffer.lb();
  31.241 +            for (TypeAnnotationProxy proxy: proxies) {
  31.242 +                Attribute.Compound compound = deproxyCompound(proxy.compound);
  31.243 +                Attribute.TypeCompound typeCompound = new Attribute.TypeCompound(compound, proxy.position);
  31.244 +                buf.add(typeCompound);
  31.245 +            }
  31.246 +            return buf.toList();
  31.247 +        }
  31.248 +
  31.249 +        @Override
  31.250 +        public void enterAnnotation() {
  31.251 +            JavaFileObject previousClassFile = currentClassFile;
  31.252 +            try {
  31.253 +                currentClassFile = classFile;
  31.254 +                List<Attribute.TypeCompound> newList = deproxyTypeCompoundList(proxies);
  31.255 +              if (debugJSR308)
  31.256 +              System.out.println("TA: reading: adding " + newList
  31.257 +                      + " to symbol " + sym + " in " + log.currentSourceFile());
  31.258 +                sym.typeAnnotations = ((sym.typeAnnotations == null)
  31.259 +                                        ? newList
  31.260 +                                        : newList.prependList(sym.typeAnnotations));
  31.261 +
  31.262 +            } finally {
  31.263 +                currentClassFile = previousClassFile;
  31.264 +            }
  31.265 +        }
  31.266 +    }
  31.267 +
  31.268  
  31.269  /************************************************************************
  31.270   * Reading Symbols

    32.1 --- a/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Fri Jun 26 10:26:27 2009 -0700
    32.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java	Sun Jun 28 00:01:09 2009 -0700
    32.3 @@ -37,7 +37,6 @@
    32.4  import com.sun.tools.javac.code.Symbol.*;
    32.5  import com.sun.tools.javac.code.Type.*;
    32.6  import com.sun.tools.javac.util.*;
    32.7 -import com.sun.tools.javac.util.List;
    32.8  
    32.9  import static com.sun.tools.javac.code.BoundKind.*;
   32.10  import static com.sun.tools.javac.code.Flags.*;
   32.11 @@ -62,6 +61,10 @@
   32.12  
   32.13      private final Options options;
   32.14  
   32.15 +    /** Switch: debugging output for JSR 308-related operations.
   32.16 +     */
   32.17 +    private boolean debugJSR308;
   32.18 +
   32.19      /** Switch: verbose output.
   32.20       */
   32.21      private boolean verbose;
   32.22 @@ -173,6 +176,7 @@
   32.23          types = Types.instance(context);
   32.24          fileManager = context.get(JavaFileManager.class);
   32.25  
   32.26 +        debugJSR308    = options.get("TA:writer") != null;
   32.27          verbose        = options.get("-verbose")     != null;
   32.28          scramble       = options.get("-scramble")    != null;
   32.29          scrambleAll    = options.get("-scrambleAll") != null;
   32.30 @@ -668,6 +672,7 @@
   32.31              acount++;
   32.32          }
   32.33          acount += writeJavaAnnotations(sym.getAnnotationMirrors());
   32.34 +        acount += writeTypeAnnotations(sym.typeAnnotations);
   32.35          return acount;
   32.36      }
   32.37  
   32.38 @@ -762,6 +767,46 @@
   32.39          return attrCount;
   32.40      }
   32.41  
   32.42 +    int writeTypeAnnotations(List<Attribute.TypeCompound> typeAnnos) {
   32.43 +        if (typeAnnos.isEmpty()) return 0;
   32.44 +
   32.45 +        ListBuffer<Attribute.TypeCompound> visibles = ListBuffer.lb();
   32.46 +        ListBuffer<Attribute.TypeCompound> invisibles = ListBuffer.lb();
   32.47 +
   32.48 +        for (Attribute.TypeCompound tc : typeAnnos) {
   32.49 +            if (tc.position.type == TargetType.UNKNOWN
   32.50 +                || !tc.position.emitToClassfile())
   32.51 +                continue;
   32.52 +            switch (getRetention(tc.type.tsym)) {
   32.53 +            case SOURCE: break;
   32.54 +            case CLASS: invisibles.append(tc); break;
   32.55 +            case RUNTIME: visibles.append(tc); break;
   32.56 +            default: ;// /* fail soft */ throw new AssertionError(vis);
   32.57 +            }
   32.58 +        }
   32.59 +
   32.60 +        int attrCount = 0;
   32.61 +        if (visibles.length() != 0) {
   32.62 +            int attrIndex = writeAttr(names.RuntimeVisibleTypeAnnotations);
   32.63 +            databuf.appendChar(visibles.length());
   32.64 +            for (Attribute.TypeCompound p : visibles)
   32.65 +                writeTypeAnnotation(p);
   32.66 +            endAttr(attrIndex);
   32.67 +            attrCount++;
   32.68 +        }
   32.69 +
   32.70 +        if (invisibles.length() != 0) {
   32.71 +            int attrIndex = writeAttr(names.RuntimeInvisibleTypeAnnotations);
   32.72 +            databuf.appendChar(invisibles.length());
   32.73 +            for (Attribute.TypeCompound p : invisibles)
   32.74 +                writeTypeAnnotation(p);
   32.75 +            endAttr(attrIndex);
   32.76 +            attrCount++;
   32.77 +        }
   32.78 +
   32.79 +        return attrCount;
   32.80 +    }
   32.81 +
   32.82      /** A mirror of java.lang.annotation.RetentionPolicy. */
   32.83      enum RetentionPolicy {
   32.84          SOURCE,
   32.85 @@ -862,6 +907,103 @@
   32.86          }
   32.87      }
   32.88  
   32.89 +    void writeTypeAnnotation(Attribute.TypeCompound c) {
   32.90 +        if (debugJSR308)
   32.91 +            System.out.println("TA: writing " + c + " at " + c.position
   32.92 +                    + " in " + log.currentSourceFile());
   32.93 +        writeCompoundAttribute(c);
   32.94 +        writePosition(c.position);
   32.95 +    }
   32.96 +
   32.97 +    void writePosition(TypeAnnotationPosition p) {
   32.98 +        databuf.appendByte(p.type.targetTypeValue());
   32.99 +        switch (p.type) {
  32.100 +        // type case
  32.101 +        case TYPECAST:
  32.102 +        case TYPECAST_GENERIC_OR_ARRAY:
  32.103 +        // object creation
  32.104 +        case INSTANCEOF:
  32.105 +        case INSTANCEOF_GENERIC_OR_ARRAY:
  32.106 +        // new expression
  32.107 +        case NEW:
  32.108 +        case NEW_GENERIC_OR_ARRAY:
  32.109 +            databuf.appendChar(p.offset);
  32.110 +            break;
  32.111 +         // local variable
  32.112 +        case LOCAL_VARIABLE:
  32.113 +        case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
  32.114 +            databuf.appendChar(p.lvarOffset.length);  // for table length
  32.115 +            for (int i = 0; i < p.lvarOffset.length; ++i) {
  32.116 +                databuf.appendChar(p.lvarOffset[i]);
  32.117 +                databuf.appendChar(p.lvarLength[i]);
  32.118 +                databuf.appendChar(p.lvarIndex[i]);
  32.119 +            }
  32.120 +            break;
  32.121 +         // method receiver
  32.122 +        case METHOD_RECEIVER:
  32.123 +            // Do nothing
  32.124 +            break;
  32.125 +        // type parameters
  32.126 +        case CLASS_TYPE_PARAMETER:
  32.127 +        case METHOD_TYPE_PARAMETER:
  32.128 +            databuf.appendByte(p.parameter_index);
  32.129 +            break;
  32.130 +        // type parameters bounds
  32.131 +        case CLASS_TYPE_PARAMETER_BOUND:
  32.132 +        case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  32.133 +        case METHOD_TYPE_PARAMETER_BOUND:
  32.134 +        case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
  32.135 +            databuf.appendByte(p.parameter_index);
  32.136 +            databuf.appendByte(p.bound_index);
  32.137 +            break;
  32.138 +         // wildcards
  32.139 +        case WILDCARD_BOUND:
  32.140 +        case WILDCARD_BOUND_GENERIC_OR_ARRAY:
  32.141 +            writePosition(p.wildcard_position);
  32.142 +            break;
  32.143 +         // Class extends and implements clauses
  32.144 +        case CLASS_EXTENDS:
  32.145 +        case CLASS_EXTENDS_GENERIC_OR_ARRAY:
  32.146 +            databuf.appendByte(p.type_index);
  32.147 +            break;
  32.148 +        // throws
  32.149 +        case THROWS:
  32.150 +            databuf.appendByte(p.type_index);
  32.151 +            break;
  32.152 +        case CLASS_LITERAL:
  32.153 +        case CLASS_LITERAL_GENERIC_OR_ARRAY:
  32.154 +            databuf.appendChar(p.offset);
  32.155 +            break;
  32.156 +        // method parameter: not specified
  32.157 +        case METHOD_PARAMETER_GENERIC_OR_ARRAY:
  32.158 +            databuf.appendByte(p.parameter_index);
  32.159 +            break;
  32.160 +        // method type argument: wasn't specified
  32.161 +        case NEW_TYPE_ARGUMENT:
  32.162 +        case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  32.163 +        case METHOD_TYPE_ARGUMENT:
  32.164 +        case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
  32.165 +            databuf.appendChar(p.offset);
  32.166 +            databuf.appendByte(p.type_index);
  32.167 +            break;
  32.168 +        // We don't need to worry abut these
  32.169 +        case METHOD_RETURN_GENERIC_OR_ARRAY:
  32.170 +        case FIELD_GENERIC_OR_ARRAY:
  32.171 +            break;
  32.172 +        case UNKNOWN:
  32.173 +            break;
  32.174 +        default:
  32.175 +            throw new AssertionError("unknown position: " + p);
  32.176 +        }
  32.177 +
  32.178 +        // Append location data for generics/arrays.
  32.179 +        if (p.type.hasLocation()) {
  32.180 +            databuf.appendChar(p.location.size());
  32.181 +            for (int i : p.location)
  32.182 +                databuf.appendByte((byte)i);
  32.183 +        }
  32.184 +    }
  32.185 +
  32.186  /**********************************************************************
  32.187   * Writing Objects
  32.188   **********************************************************************/
  32.189 @@ -1569,6 +1711,7 @@
  32.190  
  32.191          acount += writeFlagAttrs(c.flags());
  32.192          acount += writeJavaAnnotations(c.getAnnotationMirrors());
  32.193 +        acount += writeTypeAnnotations(c.typeAnnotations);
  32.194          acount += writeEnclosingMethodAttribute(c);
  32.195  
  32.196          poolbuf.appendInt(JAVA_MAGIC);

    33.1 --- a/src/share/classes/com/sun/tools/javac/jvm/Code.java	Fri Jun 26 10:26:27 2009 -0700
    33.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/Code.java	Sun Jun 28 00:01:09 2009 -0700
    33.3 @@ -1912,12 +1912,29 @@
    33.4                  if (length < Character.MAX_VALUE) {
    33.5                      v.length = length;
    33.6                      putVar(v);
    33.7 +                    fillLocalVarPosition(v);
    33.8                  }
    33.9              }
   33.10          }
   33.11          state.defined.excl(adr);
   33.12      }
   33.13  
   33.14 +    private void fillLocalVarPosition(LocalVar lv) {
   33.15 +        if (lv == null || lv.sym == null
   33.16 +                || lv.sym.typeAnnotations == null)
   33.17 +            return;
   33.18 +        for (Attribute.TypeCompound ta : lv.sym.typeAnnotations) {
   33.19 +            TypeAnnotationPosition p = ta.position;
   33.20 +            while (p != null) {
   33.21 +                p.lvarOffset[0] = (int)lv.start_pc;
   33.22 +                p.lvarLength[0] = (int)lv.length;
   33.23 +                p.lvarIndex[0] = (int)lv.reg;
   33.24 +                p.isValidOffset = true;
   33.25 +                p = p.wildcard_position;
   33.26 +            }
   33.27 +        }
   33.28 +    }
   33.29 +
   33.30      /** Put a live variable range into the buffer to be output to the
   33.31       *  class file.
   33.32       */

    34.1 --- a/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Fri Jun 26 10:26:27 2009 -0700
    34.2 +++ b/src/share/classes/com/sun/tools/javac/jvm/Gen.java	Sun Jun 28 00:01:09 2009 -0700
    34.3 @@ -26,6 +26,8 @@
    34.4  package com.sun.tools.javac.jvm;
    34.5  import java.util.*;
    34.6  
    34.7 +import javax.lang.model.element.ElementKind;
    34.8 +
    34.9  import com.sun.tools.javac.util.*;
   34.10  import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
   34.11  import com.sun.tools.javac.util.List;
   34.12 @@ -939,7 +941,6 @@
   34.13                                   startpcCrt,
   34.14                                   code.curPc());
   34.15  
   34.16 -                // End the scope of all local variables in variable info.
   34.17                  code.endScopes(0);
   34.18  
   34.19                  // If we exceeded limits, panic
   34.20 @@ -1439,7 +1440,6 @@
   34.21              // Resolve all breaks.
   34.22              code.resolve(exitChain);
   34.23  
   34.24 -            // End the scopes of all try-local variables in variable info.
   34.25              code.endScopes(limit);
   34.26          }
   34.27  
   34.28 @@ -1672,6 +1672,7 @@
   34.29   *************************************************************************/
   34.30  
   34.31      public void visitApply(JCMethodInvocation tree) {
   34.32 +        setTypeAnnotationPositions(tree.pos);
   34.33          // Generate code for method.
   34.34          Item m = genExpr(tree.meth, methodType);
   34.35          // Generate code for all arguments, where the expected types are
   34.36 @@ -1707,10 +1708,48 @@
   34.37          result = items.makeStackItem(pt);
   34.38      }
   34.39  
   34.40 +    private void setTypeAnnotationPositions(int treePos) {
   34.41 +        MethodSymbol meth = code.meth;
   34.42 +
   34.43 +        for (Attribute.TypeCompound ta : meth.typeAnnotations) {
   34.44 +            if (ta.position.pos == treePos) {
   34.45 +                ta.position.offset = code.cp;
   34.46 +                ta.position.lvarOffset[0] = code.cp;
   34.47 +                ta.position.isValidOffset = true;
   34.48 +            }
   34.49 +        }
   34.50 +
   34.51 +        if (code.meth.getKind() != ElementKind.CONSTRUCTOR
   34.52 +                && code.meth.getKind() != ElementKind.STATIC_INIT)
   34.53 +            return;
   34.54 +
   34.55 +        for (Attribute.TypeCompound ta : meth.owner.typeAnnotations) {
   34.56 +            if (ta.position.pos == treePos) {
   34.57 +                ta.position.offset = code.cp;
   34.58 +                ta.position.lvarOffset[0] = code.cp;
   34.59 +                ta.position.isValidOffset = true;
   34.60 +            }
   34.61 +        }
   34.62 +
   34.63 +        ClassSymbol clazz = meth.enclClass();
   34.64 +        for (Symbol s : new com.sun.tools.javac.model.FilteredMemberList(clazz.members())) {
   34.65 +            if (!s.getKind().isField())
   34.66 +                continue;
   34.67 +            for (Attribute.TypeCompound ta : s.typeAnnotations) {
   34.68 +                if (ta.position.pos == treePos) {
   34.69 +                    ta.position.offset = code.cp;
   34.70 +                    ta.position.lvarOffset[0] = code.cp;
   34.71 +                    ta.position.isValidOffset = true;
   34.72 +                }
   34.73 +            }
   34.74 +        }
   34.75 +    }
   34.76 +
   34.77      public void visitNewClass(JCNewClass tree) {
   34.78          // Enclosing instances or anonymous classes should have been eliminated
   34.79          // by now.
   34.80          assert tree.encl == null && tree.def == null;
   34.81 +        setTypeAnnotationPositions(tree.pos);
   34.82  
   34.83          code.emitop2(new_, makeRef(tree.pos(), tree.type));
   34.84          code.emitop0(dup);
   34.85 @@ -1725,6 +1764,8 @@
   34.86      }
   34.87  
   34.88      public void visitNewArray(JCNewArray tree) {
   34.89 +        setTypeAnnotationPositions(tree.pos);
   34.90 +
   34.91          if (tree.elems != null) {
   34.92              Type elemtype = types.elemtype(tree.type);
   34.93              loadIntConst(tree.elems.length());
   34.94 @@ -2053,6 +2094,7 @@
   34.95          }
   34.96  
   34.97      public void visitTypeCast(JCTypeCast tree) {
   34.98 +        setTypeAnnotationPositions(tree.pos);
   34.99          result = genExpr(tree.expr, tree.clazz.type).load();
  34.100          // Additional code is only needed if we cast to a reference type
  34.101          // which is not statically a supertype of the expression's type.
  34.102 @@ -2069,6 +2111,8 @@
  34.103      }
  34.104  
  34.105      public void visitTypeTest(JCInstanceOf tree) {
  34.106 +        setTypeAnnotationPositions(tree.pos);
  34.107 +
  34.108          genExpr(tree.expr, tree.expr.type).load();
  34.109          code.emitop2(instanceof_, makeRef(tree.pos(), tree.clazz.type));
  34.110          result = items.makeStackItem(syms.booleanType);
  34.111 @@ -2110,6 +2154,7 @@
  34.112  
  34.113          if (tree.name == names._class) {
  34.114              assert target.hasClassLiterals();
  34.115 +            setTypeAnnotationPositions(tree.pos);
  34.116              code.emitop2(ldc2, makeRef(tree.pos(), tree.selected.type));
  34.117              result = items.makeStackItem(pt);
  34.118              return;

    35.1 --- a/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Fri Jun 26 10:26:27 2009 -0700
    35.2 +++ b/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Sun Jun 28 00:01:09 2009 -0700
    35.3 @@ -477,7 +477,7 @@
    35.4      public Todo todo;
    35.5  
    35.6      /** Ordered list of compiler phases for each compilation unit. */
    35.7 -    protected enum CompileState {
    35.8 +    public enum CompileState {
    35.9          PARSE(1),
   35.10          ENTER(2),
   35.11          PROCESS(3),

    36.1 --- a/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Fri Jun 26 10:26:27 2009 -0700
    36.2 +++ b/src/share/classes/com/sun/tools/javac/parser/JavacParser.java	Sun Jun 28 00:01:09 2009 -0700
    36.3 @@ -75,6 +75,42 @@
    36.4      /** The name table. */
    36.5      private Names names;
    36.6  
    36.7 +    // Because of javac's limited lookahead, some contexts are ambiguous in
    36.8 +    // the presence of type annotations even though they are not ambiguous
    36.9 +    // in the absence of type annotations.  Consider this code:
   36.10 +    //   void m(String [] m) { }
   36.11 +    //   void m(String ... m) { }
   36.12 +    // After parsing "String", javac calls bracketsOpt which immediately
   36.13 +    // returns if the next character is not '['.  Similarly, javac can see
   36.14 +    // if the next token is ... and in that case parse an ellipsis.  But in
   36.15 +    // the presence of type annotations:
   36.16 +    //   void m(String @A [] m) { }
   36.17 +    //   void m(String @A ... m) { }
   36.18 +    // no finite lookahead is enough to determine whether to read array
   36.19 +    // levels or an ellipsis.  Furthermore, if you call bracketsOpt, then
   36.20 +    // bracketsOpt first reads all the leading annotations and only then
   36.21 +    // discovers that it needs to fail.  bracketsOpt needs a way to push
   36.22 +    // back the extra annotations that it read.  (But, bracketsOpt should
   36.23 +    // not *always* be allowed to push back extra annotations that it finds
   36.24 +    // -- in most contexts, any such extra annotation is an error.
   36.25 +    // Another similar case occurs with arrays and receiver annotations:
   36.26 +    //   String b() @Array [] @Receiver { }
   36.27 +    //   String b() @Receiver { }
   36.28 +    //
   36.29 +    // The following two variables permit type annotations that have
   36.30 +    // already been read to be stored for later use.  Alternate
   36.31 +    // implementations are possible but would cause much larger changes to
   36.32 +    // the parser.
   36.33 +    /** Type annotations that have already been read but have not yet been used. **/
   36.34 +    private List<JCTypeAnnotation> typeAnnotationsPushedBack = null;
   36.35 +    /**
   36.36 +     * If the parser notices extra annotations, then it either immediately
   36.37 +     * issues an error (if this variable is false) or places the extra
   36.38 +     * annotations in variable typeAnnotationsPushedBack (if this variable
   36.39 +     * is true).
   36.40 +     */
   36.41 +    private boolean permitTypeAnnotationsPushBack = false;
   36.42 +
   36.43      /** Construct a parser from a given scanner, tree factory and log.
   36.44       */
   36.45      protected JavacParser(ParserFactory fac,
   36.46 @@ -95,13 +131,19 @@
   36.47          this.allowForeach = source.allowForeach();
   36.48          this.allowStaticImport = source.allowStaticImport();
   36.49          this.allowAnnotations = source.allowAnnotations();
   36.50 +        this.allowTypeAnnotations = source.allowTypeAnnotations();
   36.51          this.keepDocComments = keepDocComments;
   36.52          if (keepDocComments)
   36.53              docComments = new HashMap<JCTree,String>();
   36.54          this.keepLineMap = keepLineMap;
   36.55          this.errorTree = F.Erroneous();
   36.56 +        this.debugJSR308 = fac.options.get("TA:parser") != null;
   36.57      }
   36.58  
   36.59 +    /** Switch: debug output for type-annotations operations
   36.60 +     */
   36.61 +    boolean debugJSR308;
   36.62 +
   36.63      /** Switch: Should generics be recognized?
   36.64       */
   36.65      boolean allowGenerics;
   36.66 @@ -130,6 +172,10 @@
   36.67       */
   36.68      boolean allowAnnotations;
   36.69  
   36.70 +    /** Switch: should we recognize type annotations?
   36.71 +     */
   36.72 +    boolean allowTypeAnnotations;
   36.73 +
   36.74      /** Switch: should we keep docComments?
   36.75       */
   36.76      boolean keepDocComments;
   36.77 @@ -558,7 +604,33 @@
   36.78          return term(EXPR);
   36.79      }
   36.80  
   36.81 +    /**
   36.82 +     * parses (optional) type annotations followed by a type. If the
   36.83 +     * annotations are present before the type and are not consumed during array
   36.84 +     * parsing, this method returns a {@link JCAnnotatedType} consisting of
   36.85 +     * these annotations and the underlying type. Otherwise, it returns the
   36.86 +     * underlying type.
   36.87 +     *
   36.88 +     * <p>
   36.89 +     *
   36.90 +     * Note that this method sets {@code mode} to {@code TYPE} first, before
   36.91 +     * parsing annotations.
   36.92 +     */
   36.93      public JCExpression parseType() {
   36.94 +        List<JCTypeAnnotation> annotations = typeAnnotationsOpt();
   36.95 +        return parseType(annotations);
   36.96 +    }
   36.97 +
   36.98 +    public JCExpression parseType(List<JCTypeAnnotation> annotations) {
   36.99 +        JCExpression result = unannotatedType();
  36.100 +
  36.101 +        if (!annotations.isEmpty())
  36.102 +            result = F.AnnotatedType(annotations, result);
  36.103 +
  36.104 +        return result;
  36.105 +    }
  36.106 +
  36.107 +    public JCExpression unannotatedType() {
  36.108          return term(TYPE);
  36.109      }
  36.110  
  36.111 @@ -792,8 +864,8 @@
  36.112       *                 | [TypeArguments] THIS [Arguments]
  36.113       *                 | [TypeArguments] SUPER SuperSuffix
  36.114       *                 | NEW [TypeArguments] Creator
  36.115 -     *                 | Ident { "." Ident }
  36.116 -     *                   [ "[" ( "]" BracketsOpt "." CLASS | Expression "]" )
  36.117 +     *                 | [Annotations] Ident { "." Ident }
  36.118 +     *                   [ [Annotations] "[" ( "]" BracketsOpt "." CLASS | Expression "]" )
  36.119       *                   | Arguments
  36.120       *                   | "." ( CLASS | THIS | [TypeArguments] SUPER Arguments | NEW [TypeArguments] InnerCreator )
  36.121       *                   ]
  36.122 @@ -942,23 +1014,62 @@
  36.123                  typeArgs = null;
  36.124              } else return illegal();
  36.125              break;
  36.126 +        case MONKEYS_AT:
  36.127 +
  36.128 +            // only annotated targetting class literals or cast types are valid
  36.129 +            List<JCTypeAnnotation> typeAnnos = typeAnnotationsOpt();
  36.130 +            if (typeAnnos.isEmpty()) {
  36.131 +                // else there would be no '@'
  36.132 +                throw new AssertionError("type annos is empty");
  36.133 +            }
  36.134 +
  36.135 +            JCExpression expr = term3();
  36.136 +
  36.137 +            // Type annotations: If term3 just parsed a non-type, expect a
  36.138 +            // class literal (and issue a syntax error if there is no class
  36.139 +            // literal). Otherwise, create a JCAnnotatedType.
  36.140 +            if ((mode & TYPE) == 0) {
  36.141 +                if (expr.getTag() != JCTree.SELECT)
  36.142 +                    return illegal(typeAnnos.head.pos);
  36.143 +                JCFieldAccess sel = (JCFieldAccess)expr;
  36.144 +                if (sel.name != names._class)
  36.145 +                    return illegal();
  36.146 +                else {
  36.147 +                    sel.selected = F.AnnotatedType(typeAnnos, sel.selected);
  36.148 +                    t = expr;
  36.149 +                }
  36.150 +            } else {
  36.151 +                // type annotation targeting a cast
  36.152 +                t = toP(F.at(S.pos()).AnnotatedType(typeAnnos, expr));
  36.153 +            }
  36.154 +            break;
  36.155          case IDENTIFIER: case ASSERT: case ENUM:
  36.156              if (typeArgs != null) return illegal();
  36.157              t = toP(F.at(S.pos()).Ident(ident()));
  36.158              loop: while (true) {
  36.159                  pos = S.pos();
  36.160 +                final List<JCTypeAnnotation> annos = typeAnnotationsOpt();
  36.161 +
  36.162 +                // need to report an error later if LBRACKET is for array
  36.163 +                // index access rather than array creation level
  36.164 +                if (!annos.isEmpty() && S.token() != LBRACKET && S.token() != ELLIPSIS)
  36.165 +                    return illegal(annos.head.pos);
  36.166                  switch (S.token()) {
  36.167                  case LBRACKET:
  36.168                      S.nextToken();
  36.169 +
  36.170                      if (S.token() == RBRACKET) {
  36.171 +
  36.172                          S.nextToken();
  36.173 -                        t = bracketsOpt(t);
  36.174 +
  36.175 +                        t = bracketsOpt(t, annos);
  36.176                          t = toP(F.at(pos).TypeArray(t));
  36.177                          t = bracketsSuffix(t);
  36.178                      } else {
  36.179                          if ((mode & EXPR) != 0) {
  36.180                              mode = EXPR;
  36.181                              JCExpression t1 = term();
  36.182 +                            if (!annos.isEmpty()) t = illegal(annos.head.pos);
  36.183                              t = to(F.at(pos).Indexed(t, t1));
  36.184                          }
  36.185                          accept(RBRACKET);
  36.186 @@ -1011,6 +1122,10 @@
  36.187                      // typeArgs saved for next loop iteration.
  36.188                      t = toP(F.at(pos).Select(t, ident()));
  36.189                      break;
  36.190 +                case ELLIPSIS:
  36.191 +                    assert this.permitTypeAnnotationsPushBack;
  36.192 +                    typeAnnotationsPushedBack = annos;
  36.193 +                    break loop;
  36.194                  default:
  36.195                      break loop;
  36.196                  }
  36.197 @@ -1049,14 +1164,18 @@
  36.198          if (typeArgs != null) illegal();
  36.199          while (true) {
  36.200              int pos1 = S.pos();
  36.201 +
  36.202 +            final List<JCTypeAnnotation> annos = typeAnnotationsOpt();
  36.203 +
  36.204              if (S.token() == LBRACKET) {
  36.205                  S.nextToken();
  36.206 +
  36.207                  if ((mode & TYPE) != 0) {
  36.208                      int oldmode = mode;
  36.209                      mode = TYPE;
  36.210                      if (S.token() == RBRACKET) {
  36.211                          S.nextToken();
  36.212 -                        t = bracketsOpt(t);
  36.213 +                        t = bracketsOpt(t, annos);
  36.214                          t = toP(F.at(pos1).TypeArray(t));
  36.215                          return t;
  36.216                      }
  36.217 @@ -1091,6 +1210,12 @@
  36.218                      typeArgs = null;
  36.219                  }
  36.220              } else {
  36.221 +                if (!annos.isEmpty()) {
  36.222 +                    if (permitTypeAnnotationsPushBack)
  36.223 +                        typeAnnotationsPushedBack = annos;
  36.224 +                    else
  36.225 +                        return illegal(annos.head.pos);
  36.226 +                }
  36.227                  break;
  36.228              }
  36.229          }
  36.230 @@ -1100,6 +1225,7 @@
  36.231                    S.token() == PLUSPLUS ? JCTree.POSTINC : JCTree.POSTDEC, t));
  36.232              S.nextToken();
  36.233          }
  36.234 +
  36.235          return toP(t);
  36.236      }
  36.237  
  36.238 @@ -1232,22 +1358,24 @@
  36.239      }
  36.240  
  36.241      /** TypeArgument = Type
  36.242 -     *               | "?"
  36.243 -     *               | "?" EXTENDS Type {"&" Type}
  36.244 -     *               | "?" SUPER Type
  36.245 +     *               | [Annotations] "?"
  36.246 +     *               | [Annotations] "?" EXTENDS Type {"&" Type}
  36.247 +     *               | [Annotations] "?" SUPER Type
  36.248       */
  36.249      JCExpression typeArgument() {
  36.250 -        if (S.token() != QUES) return parseType();
  36.251 +        List<JCTypeAnnotation> annotations = typeAnnotationsOpt();
  36.252 +        if (S.token() != QUES) return parseType(annotations);
  36.253          int pos = S.pos();
  36.254          S.nextToken();
  36.255 +        JCExpression result;
  36.256          if (S.token() == EXTENDS) {
  36.257              TypeBoundKind t = to(F.at(S.pos()).TypeBoundKind(BoundKind.EXTENDS));
  36.258              S.nextToken();
  36.259 -            return F.at(pos).Wildcard(t, parseType());
  36.260 +            result = F.at(pos).Wildcard(t, parseType());
  36.261          } else if (S.token() == SUPER) {
  36.262              TypeBoundKind t = to(F.at(S.pos()).TypeBoundKind(BoundKind.SUPER));
  36.263              S.nextToken();
  36.264 -            return F.at(pos).Wildcard(t, parseType());
  36.265 +            result = F.at(pos).Wildcard(t, parseType());
  36.266          } else if (S.token() == IDENTIFIER) {
  36.267              //error recovery
  36.268              reportSyntaxError(S.prevEndPos(), "expected3",
  36.269 @@ -1255,11 +1383,14 @@
  36.270              TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(BoundKind.UNBOUND);
  36.271              JCExpression wc = toP(F.at(pos).Wildcard(t, null));
  36.272              JCIdent id = toP(F.at(S.pos()).Ident(ident()));
  36.273 -            return F.at(pos).Erroneous(List.<JCTree>of(wc, id));
  36.274 +            result = F.at(pos).Erroneous(List.<JCTree>of(wc, id));
  36.275          } else {
  36.276              TypeBoundKind t = F.at(Position.NOPOS).TypeBoundKind(BoundKind.UNBOUND);
  36.277 -            return toP(F.at(pos).Wildcard(t, null));
  36.278 +            result = toP(F.at(pos).Wildcard(t, null));
  36.279          }
  36.280 +        if (!annotations.isEmpty())
  36.281 +            result = toP(F.at(annotations.head.pos).AnnotatedType(annotations,result));
  36.282 +        return result;
  36.283      }
  36.284  
  36.285      JCTypeApply typeArguments(JCExpression t) {
  36.286 @@ -1268,21 +1399,47 @@
  36.287          return toP(F.at(pos).TypeApply(t, args));
  36.288      }
  36.289  
  36.290 -    /** BracketsOpt = {"[" "]"}
  36.291 +    /**
  36.292 +     * BracketsOpt = { [Annotations] "[" "]" }
  36.293 +     *
  36.294 +     * <p>
  36.295 +     *
  36.296 +     * <code>annotations</code> is the list of annotations targeting
  36.297 +     * the expression <code>t</code>.
  36.298       */
  36.299 -    private JCExpression bracketsOpt(JCExpression t) {
  36.300 +    private JCExpression bracketsOpt(JCExpression t,
  36.301 +            List<JCTypeAnnotation> annotations) {
  36.302 +        List<JCTypeAnnotation> nextLevelAnnotations = typeAnnotationsOpt();
  36.303 +
  36.304          if (S.token() == LBRACKET) {
  36.305              int pos = S.pos();
  36.306              S.nextToken();
  36.307 -            t = bracketsOptCont(t, pos);
  36.308 -            F.at(pos);
  36.309 +
  36.310 +            JCExpression orig = t;
  36.311 +            t = bracketsOptCont(t, pos, nextLevelAnnotations);
  36.312 +        } else if (!nextLevelAnnotations.isEmpty()) {
  36.313 +            if (permitTypeAnnotationsPushBack) {
  36.314 +                this.typeAnnotationsPushedBack = nextLevelAnnotations;
  36.315 +            } else
  36.316 +                return illegal(nextLevelAnnotations.head.pos);
  36.317          }
  36.318 +
  36.319 +        int apos = S.pos();
  36.320 +        if (!annotations.isEmpty())
  36.321 +            t = F.at(apos).AnnotatedType(annotations, t);
  36.322          return t;
  36.323      }
  36.324  
  36.325 -    private JCArrayTypeTree bracketsOptCont(JCExpression t, int pos) {
  36.326 +    /** BracketsOpt = {"[" TypeAnnotations "]"}
  36.327 +     */
  36.328 +    private JCExpression bracketsOpt(JCExpression t) {
  36.329 +        return bracketsOpt(t, List.<JCTypeAnnotation>nil());
  36.330 +    }
  36.331 +
  36.332 +    private JCArrayTypeTree bracketsOptCont(JCExpression t, int pos,
  36.333 +            List<JCTypeAnnotation> annotations) {
  36.334          accept(RBRACKET);
  36.335 -        t = bracketsOpt(t);
  36.336 +        t = bracketsOpt(t, annotations);
  36.337          return toP(F.at(pos).TypeArray(t));
  36.338      }
  36.339  
  36.340 @@ -1316,18 +1473,29 @@
  36.341          return t;
  36.342      }
  36.343  
  36.344 -    /** Creator = Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
  36.345 +    /** Creator = [Annotations] Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
  36.346       */
  36.347      JCExpression creator(int newpos, List<JCExpression> typeArgs) {
  36.348 +
  36.349 +        List<JCTypeAnnotation> newAnnotations = typeAnnotationsOpt();
  36.350 +
  36.351          switch (S.token()) {
  36.352          case BYTE: case SHORT: case CHAR: case INT: case LONG: case FLOAT:
  36.353          case DOUBLE: case BOOLEAN:
  36.354 -            if (typeArgs == null)
  36.355 -                return arrayCreatorRest(newpos, basicType());
  36.356 +            if (typeArgs == null) {
  36.357 +                if (newAnnotations.isEmpty())
  36.358 +                    return arrayCreatorRest(newpos, basicType());
  36.359 +                else
  36.360 +                    return arrayCreatorRest(newpos, F.AnnotatedType(newAnnotations, basicType()));
  36.361 +            }
  36.362              break;
  36.363          default:
  36.364          }
  36.365          JCExpression t = qualident();
  36.366 +        // handle type annotations for non primitive arrays
  36.367 +        if (!newAnnotations.isEmpty())
  36.368 +            t = F.AnnotatedType(newAnnotations, t);
  36.369 +
  36.370          int oldmode = mode;
  36.371          mode = TYPE;
  36.372          if (S.token() == LT) {
  36.373 @@ -1344,7 +1512,7 @@
  36.374              }
  36.375          }
  36.376          mode = oldmode;
  36.377 -        if (S.token() == LBRACKET) {
  36.378 +        if (S.token() == LBRACKET || S.token() == MONKEYS_AT) {
  36.379              JCExpression e = arrayCreatorRest(newpos, t);
  36.380              if (typeArgs != null) {
  36.381                  int pos = newpos;
  36.382 @@ -1360,7 +1528,12 @@
  36.383              }
  36.384              return e;
  36.385          } else if (S.token() == LPAREN) {
  36.386 -            return classCreatorRest(newpos, null, typeArgs, t);
  36.387 +            JCNewClass newClass = classCreatorRest(newpos, null, typeArgs, t);
  36.388 +            if (newClass.def != null) {
  36.389 +                assert newClass.def.mods.annotations.isEmpty();
  36.390 +                newClass.def.mods.annotations = List.convert(JCAnnotation.class, newAnnotations);
  36.391 +            }
  36.392 +            return newClass;
  36.393          } else {
  36.394              reportSyntaxError(S.pos(), "expected2",
  36.395                                 LPAREN, LBRACKET);
  36.396 @@ -1380,40 +1553,73 @@
  36.397          return classCreatorRest(newpos, encl, typeArgs, t);
  36.398      }
  36.399  
  36.400 -    /** ArrayCreatorRest = "[" ( "]" BracketsOpt ArrayInitializer
  36.401 -     *                         | Expression "]" {"[" Expression "]"} BracketsOpt )
  36.402 +    /** ArrayCreatorRest = [Annotations] "[" ( "]" BracketsOpt ArrayInitializer
  36.403 +     *                         | Expression "]" {[Annotations]  "[" Expression "]"} BracketsOpt )
  36.404       */
  36.405      JCExpression arrayCreatorRest(int newpos, JCExpression elemtype) {
  36.406 +
  36.407 +        List<JCTypeAnnotation> topAnnos = List.nil();
  36.408 +        if (elemtype.getTag() == JCTree.ANNOTATED_TYPE) {
  36.409 +            JCAnnotatedType atype = (JCAnnotatedType) elemtype;
  36.410 +            topAnnos = atype.annotations;
  36.411 +            elemtype = atype.underlyingType;
  36.412 +        }
  36.413 +
  36.414 +        List<JCTypeAnnotation> annos = typeAnnotationsOpt();
  36.415 +
  36.416          accept(LBRACKET);
  36.417 +
  36.418          if (S.token() == RBRACKET) {
  36.419              accept(RBRACKET);
  36.420 -            elemtype = bracketsOpt(elemtype);
  36.421 +
  36.422 +            elemtype = bracketsOpt(elemtype, annos);
  36.423 +
  36.424              if (S.token() == LBRACE) {
  36.425 -                return arrayInitializer(newpos, elemtype);
  36.426 +                JCNewArray na = (JCNewArray)arrayInitializer(newpos, elemtype);
  36.427 +
  36.428 +                na.annotations = topAnnos;
  36.429 +
  36.430 +                return na;
  36.431              } else {
  36.432                  return syntaxError(S.pos(), "array.dimension.missing");
  36.433              }
  36.434          } else {
  36.435              ListBuffer<JCExpression> dims = new ListBuffer<JCExpression>();
  36.436 +
  36.437 +            // maintain array dimension type annotations
  36.438 +            ListBuffer<List<JCTypeAnnotation>> dimAnnotations = ListBuffer.lb();
  36.439 +            dimAnnotations.append(annos);
  36.440 +
  36.441              dims.append(parseExpression());
  36.442              accept(RBRACKET);
  36.443 -            while (S.token() == LBRACKET) {
  36.444 +            while (S.token() == LBRACKET
  36.445 +                    || (S.token() == MONKEYS_AT)) {
  36.446 +                List<JCTypeAnnotation> maybeDimAnnos = typeAnnotationsOpt();
  36.447                  int pos = S.pos();
  36.448                  S.nextToken();
  36.449                  if (S.token() == RBRACKET) {
  36.450 -                    elemtype = bracketsOptCont(elemtype, pos);
  36.451 +                    elemtype = bracketsOptCont(elemtype, pos, maybeDimAnnos);
  36.452                  } else {
  36.453 -                    dims.append(parseExpression());
  36.454 -                    accept(RBRACKET);
  36.455 +                    if (S.token() == RBRACKET) { // no dimension
  36.456 +                        elemtype = bracketsOptCont(elemtype, pos, maybeDimAnnos);
  36.457 +                    } else {
  36.458 +                        dimAnnotations.append(maybeDimAnnos);
  36.459 +                        dims.append(parseExpression());
  36.460 +                        accept(RBRACKET);
  36.461 +                    }
  36.462                  }
  36.463              }
  36.464 -            return toP(F.at(newpos).NewArray(elemtype, dims.toList(), null));
  36.465 +
  36.466 +            JCNewArray na = toP(F.at(newpos).NewArray(elemtype, dims.toList(), null));
  36.467 +            na.annotations = topAnnos;
  36.468 +            na.dimAnnotations = dimAnnotations.toList();
  36.469 +            return na;
  36.470          }
  36.471      }
  36.472  
  36.473      /** ClassCreatorRest = Arguments [ClassBody]
  36.474       */
  36.475 -    JCExpression classCreatorRest(int newpos,
  36.476 +    JCNewClass classCreatorRest(int newpos,
  36.477                                    JCExpression encl,
  36.478                                    List<JCExpression> typeArgs,
  36.479                                    JCExpression t)
  36.480 @@ -1860,17 +2066,32 @@
  36.481                                          new ListBuffer<JCExpressionStatement>()).toList();
  36.482      }
  36.483  
  36.484 +    enum AnnotationKind { DEFAULT_ANNO, TYPE_ANNO };
  36.485 +
  36.486      /** AnnotationsOpt = { '@' Annotation }
  36.487       */
  36.488 -    List<JCAnnotation> annotationsOpt() {
  36.489 +    List<JCAnnotation> annotationsOpt(AnnotationKind kind) {
  36.490          if (S.token() != MONKEYS_AT) return List.nil(); // optimization
  36.491          ListBuffer<JCAnnotation> buf = new ListBuffer<JCAnnotation>();
  36.492 +        int prevmode = mode;
  36.493          while (S.token() == MONKEYS_AT) {
  36.494              int pos = S.pos();
  36.495              S.nextToken();
  36.496 -            buf.append(annotation(pos));
  36.497 +            buf.append(annotation(pos, kind));
  36.498          }
  36.499 -        return buf.toList();
  36.500 +        lastmode = mode;
  36.501 +        mode = prevmode;
  36.502 +        List<JCAnnotation> annotations = buf.toList();
  36.503 +
  36.504 +        if (debugJSR308 && kind == AnnotationKind.TYPE_ANNO)
  36.505 +            System.out.println("TA: parsing " + annotations
  36.506 +                    + " in " + log.currentSourceFile());
  36.507 +        return annotations;
  36.508 +    }
  36.509 +
  36.510 +    List<JCTypeAnnotation> typeAnnotationsOpt() {
  36.511 +        List<JCAnnotation> annotations = annotationsOpt(AnnotationKind.TYPE_ANNO);
  36.512 +        return List.convert(JCTypeAnnotation.class, annotations);
  36.513      }
  36.514  
  36.515      /** ModifiersOpt = { Modifier }
  36.516 @@ -1915,7 +2136,7 @@
  36.517              if (flag == Flags.ANNOTATION) {
  36.518                  checkAnnotations();
  36.519                  if (S.token() != INTERFACE) {
  36.520 -                JCAnnotation ann = annotation(lastPos);
  36.521 +                JCAnnotation ann = annotation(lastPos, AnnotationKind.DEFAULT_ANNO);
  36.522                  // if first modifier is an annotation, set pos to annotation's.
  36.523                  if (flags == 0 && annotations.isEmpty())
  36.524                      pos = ann.pos;
  36.525 @@ -1946,12 +2167,18 @@
  36.526      /** Annotation              = "@" Qualident [ "(" AnnotationFieldValues ")" ]
  36.527       * @param pos position of "@" token
  36.528       */
  36.529 -    JCAnnotation annotation(int pos) {
  36.530 +    JCAnnotation annotation(int pos, AnnotationKind kind) {
  36.531          // accept(AT); // AT consumed by caller
  36.532          checkAnnotations();
  36.533 +        if (kind == AnnotationKind.TYPE_ANNO)
  36.534 +            checkTypeAnnotations();
  36.535          JCTree ident = qualident();
  36.536          List<JCExpression> fieldValues = annotationFieldValuesOpt();
  36.537 -        JCAnnotation ann = F.at(pos).Annotation(ident, fieldValues);
  36.538 +        JCAnnotation ann;
  36.539 +        if (kind == AnnotationKind.DEFAULT_ANNO)
  36.540 +            ann = F.at(pos).Annotation(ident, fieldValues);
  36.541 +        else
  36.542 +            ann = F.at(pos).TypeAnnotation(ident, fieldValues);
  36.543          storeEnd(ann, S.prevEndPos());
  36.544          return ann;
  36.545      }
  36.546 @@ -2003,7 +2230,7 @@
  36.547          case MONKEYS_AT:
  36.548              pos = S.pos();
  36.549              S.nextToken();
  36.550 -            return annotation(pos);
  36.551 +            return annotation(pos, AnnotationKind.DEFAULT_ANNO);
  36.552          case LBRACE:
  36.553              pos = S.pos();
  36.554              accept(LBRACE);
  36.555 @@ -2357,7 +2584,7 @@
  36.556              S.resetDeprecatedFlag();
  36.557          }
  36.558          int pos = S.pos();
  36.559 -        List<JCAnnotation> annotations = annotationsOpt();
  36.560 +        List<JCAnnotation> annotations = annotationsOpt(AnnotationKind.DEFAULT_ANNO);
  36.561          JCModifiers mods = F.at(annotations.isEmpty() ? Position.NOPOS : pos).Modifiers(flags, annotations);
  36.562          List<JCExpression> typeArgs = typeArgumentsOpt();
  36.563          int identPos = S.pos();
  36.564 @@ -2460,16 +2687,23 @@
  36.565                  if (typarams.length() > 0 && mods.pos == Position.NOPOS) {
  36.566                      mods.pos = pos;
  36.567                  }
  36.568 +
  36.569 +                List<JCAnnotation> annosAfterParams = annotationsOpt(AnnotationKind.DEFAULT_ANNO);
  36.570 +
  36.571                  Token token = S.token();
  36.572                  Name name = S.name();
  36.573                  pos = S.pos();
  36.574                  JCExpression type;
  36.575                  boolean isVoid = S.token() == VOID;
  36.576                  if (isVoid) {
  36.577 +                    if (annosAfterParams.nonEmpty())
  36.578 +                        illegal(annosAfterParams.head.pos);
  36.579                      type = to(F.at(pos).TypeIdent(TypeTags.VOID));
  36.580                      S.nextToken();
  36.581                  } else {
  36.582 -                    type = parseType();
  36.583 +                    mods.annotations = mods.annotations.appendList(annosAfterParams);
  36.584 +                    // method returns types are un-annotated types
  36.585 +                    type = unannotatedType();
  36.586                  }
  36.587                  if (S.token() == LPAREN && !isInterface && type.getTag() == JCTree.IDENT) {
  36.588                      if (isInterface || name != className)
  36.589 @@ -2505,15 +2739,15 @@
  36.590      }
  36.591  
  36.592      /** MethodDeclaratorRest =
  36.593 -     *      FormalParameters BracketsOpt [Throws TypeList] ( MethodBody | [DEFAULT AnnotationValue] ";")
  36.594 +     *      FormalParameters BracketsOpt [Annotations] [Throws TypeList] ( MethodBody | [DEFAULT AnnotationValue] ";")
  36.595       *  VoidMethodDeclaratorRest =
  36.596 -     *      FormalParameters [Throws TypeList] ( MethodBody | ";")
  36.597 +     *      FormalParameters [Annotations] [Throws TypeList] ( MethodBody | ";")
  36.598       *  InterfaceMethodDeclaratorRest =
  36.599 -     *      FormalParameters BracketsOpt [THROWS TypeList] ";"
  36.600 +     *      FormalParameters BracketsOpt [Annotations] [THROWS TypeList] ";"
  36.601       *  VoidInterfaceMethodDeclaratorRest =
  36.602 -     *      FormalParameters [THROWS TypeList] ";"
  36.603 +     *      FormalParameters [Annotations] [THROWS TypeList] ";"
  36.604       *  ConstructorDeclaratorRest =
  36.605 -     *      "(" FormalParameterListOpt ")" [THROWS TypeList] MethodBody
  36.606 +     *      "(" FormalParameterListOpt ")" [Annotations] [THROWS TypeList] MethodBody
  36.607       */
  36.608      JCTree methodDeclaratorRest(int pos,
  36.609                                JCModifiers mods,
  36.610 @@ -2523,7 +2757,22 @@
  36.611                                boolean isInterface, boolean isVoid,
  36.612                                String dc) {
  36.613          List<JCVariableDecl> params = formalParameters();
  36.614 -        if (!isVoid) type = bracketsOpt(type);
  36.615 +
  36.616 +        List<JCTypeAnnotation> receiverAnnotations;
  36.617 +        if (!isVoid) {
  36.618 +            // need to distinguish between receiver anno and array anno
  36.619 +            // look at typeAnnotationsPushedBack comment
  36.620 +            this.permitTypeAnnotationsPushBack = true;
  36.621 +            type = methodReturnArrayRest(type);
  36.622 +            this.permitTypeAnnotationsPushBack = false;
  36.623 +            if (typeAnnotationsPushedBack == null)
  36.624 +                receiverAnnotations = List.nil();
  36.625 +            else
  36.626 +                receiverAnnotations = typeAnnotationsPushedBack;
  36.627 +            typeAnnotationsPushedBack = null;
  36.628 +        } else
  36.629 +            receiverAnnotations = typeAnnotationsOpt();
  36.630 +
  36.631          List<JCExpression> thrown = List.nil();
  36.632          if (S.token() == THROWS) {
  36.633              S.nextToken();
  36.634 @@ -2552,20 +2801,51 @@
  36.635          }
  36.636          JCMethodDecl result =
  36.637              toP(F.at(pos).MethodDef(mods, name, type, typarams,
  36.638 -                                    params, thrown,
  36.639 +                                    params, receiverAnnotations, thrown,
  36.640                                      body, defaultValue));
  36.641          attach(result, dc);
  36.642          return result;
  36.643      }
  36.644  
  36.645 -    /** QualidentList = Qualident {"," Qualident}
  36.646 +    /** Parses the array levels after the format parameters list, and append
  36.647 +     * them to the return type, while preseving the order of type annotations
  36.648 +     */
  36.649 +    private JCExpression methodReturnArrayRest(JCExpression type) {
  36.650 +        if (type.getTag() != JCTree.TYPEARRAY)
  36.651 +            return bracketsOpt(type);
  36.652 +
  36.653 +        JCArrayTypeTree baseArray = (JCArrayTypeTree)type;
  36.654 +        while (TreeInfo.typeIn(baseArray.elemtype) instanceof JCArrayTypeTree)
  36.655 +            baseArray = (JCArrayTypeTree)TreeInfo.typeIn(baseArray.elemtype);
  36.656 +
  36.657 +        if (baseArray.elemtype.getTag() == JCTree.ANNOTATED_TYPE) {
  36.658 +            JCAnnotatedType at = (JCAnnotatedType)baseArray.elemtype;
  36.659 +            at.underlyingType = bracketsOpt(at.underlyingType);
  36.660 +        } else {
  36.661 +            baseArray.elemtype = bracketsOpt(baseArray.elemtype);
  36.662 +        }
  36.663 +
  36.664 +        return type;
  36.665 +    }
  36.666 +
  36.667 +    /** QualidentList = [Annotations] Qualident {"," [Annotations] Qualident}
  36.668       */
  36.669      List<JCExpression> qualidentList() {
  36.670          ListBuffer<JCExpression> ts = new ListBuffer<JCExpression>();
  36.671 -        ts.append(qualident());
  36.672 +
  36.673 +        List<JCTypeAnnotation> typeAnnos = typeAnnotationsOpt();
  36.674 +        if (!typeAnnos.isEmpty())
  36.675 +            ts.append(F.AnnotatedType(typeAnnos, qualident()));
  36.676 +        else
  36.677 +            ts.append(qualident());
  36.678          while (S.token() == COMMA) {
  36.679              S.nextToken();
  36.680 -            ts.append(qualident());
  36.681 +
  36.682 +            typeAnnos = typeAnnotationsOpt();
  36.683 +            if (!typeAnnos.isEmpty())
  36.684 +                ts.append(F.AnnotatedType(typeAnnos, qualident()));
  36.685 +            else
  36.686 +                ts.append(qualident());
  36.687          }
  36.688          return ts.toList();
  36.689      }
  36.690 @@ -2589,12 +2869,13 @@
  36.691          }
  36.692      }
  36.693  
  36.694 -    /** TypeParameter = TypeVariable [TypeParameterBound]
  36.695 +    /** TypeParameter = [Annotations] TypeVariable [TypeParameterBound]
  36.696       *  TypeParameterBound = EXTENDS Type {"&" Type}
  36.697       *  TypeVariable = Ident
  36.698       */
  36.699      JCTypeParameter typeParameter() {
  36.700          int pos = S.pos();
  36.701 +        List<JCTypeAnnotation> annos = typeAnnotationsOpt();
  36.702          Name name = ident();
  36.703          ListBuffer<JCExpression> bounds = new ListBuffer<JCExpression>();
  36.704          if (S.token() == EXTENDS) {
  36.705 @@ -2605,7 +2886,7 @@
  36.706                  bounds.append(parseType());
  36.707              }
  36.708          }
  36.709 -        return toP(F.at(pos).TypeParameter(name, bounds.toList()));
  36.710 +        return toP(F.at(pos).TypeParameter(name, bounds.toList(), annos));
  36.711      }
  36.712  
  36.713      /** FormalParameters = "(" [ FormalParameterList ] ")"
  36.714 @@ -2639,12 +2920,31 @@
  36.715       */
  36.716      JCVariableDecl formalParameter() {
  36.717          JCModifiers mods = optFinal(Flags.PARAMETER);
  36.718 +        // need to distinguish between vararg annos and array annos
  36.719 +        // look at typeAnnotaitonsPushedBack comment
  36.720 +        this.permitTypeAnnotationsPushBack = true;
  36.721          JCExpression type = parseType();
  36.722 +        this.permitTypeAnnotationsPushBack = false;
  36.723 +
  36.724          if (S.token() == ELLIPSIS) {
  36.725 +            List<JCTypeAnnotation> varargsAnnos = typeAnnotationsPushedBack;
  36.726 +            typeAnnotationsPushedBack = null;
  36.727              checkVarargs();
  36.728              mods.flags |= Flags.VARARGS;
  36.729 +            // insert var arg type annotations
  36.730 +            if (varargsAnnos != null && varargsAnnos.nonEmpty())
  36.731 +                type = F.at(S.pos()).AnnotatedType(varargsAnnos, type);
  36.732              type = to(F.at(S.pos()).TypeArray(type));
  36.733 +
  36.734              S.nextToken();
  36.735 +        } else {
  36.736 +            // if not a var arg, then typeAnnotationsPushedBack should be null
  36.737 +            if (typeAnnotationsPushedBack != null
  36.738 +                    && !typeAnnotationsPushedBack.isEmpty()) {
  36.739 +                reportSyntaxError(typeAnnotationsPushedBack.head.pos,
  36.740 +                        "illegal.start.of.type");
  36.741 +            }
  36.742 +            typeAnnotationsPushedBack = null;
  36.743          }
  36.744          return variableDeclaratorId(mods, type);
  36.745      }
  36.746 @@ -2829,4 +3129,10 @@
  36.747              allowAnnotations = true;
  36.748          }
  36.749      }
  36.750 +    void checkTypeAnnotations() {
  36.751 +        if (!allowTypeAnnotations) {
  36.752 +            log.error(S.pos(), "type.annotations.not.supported.in.source", source.name);
  36.753 +            allowTypeAnnotations = true;
  36.754 +        }
  36.755 +    }
  36.756  }