Mercurial > jdk8-mips64-public > langtools / file revision

 /*

  * Copyright 2003-2008 Sun Microsystems, Inc.  All Rights Reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.  Sun designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Sun in the LICENSE file that accompanied this code.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

  * CA 95054 USA or visit www.sun.com if you need additional information or

  * have any questions.

  */

 package com.sun.tools.javac.comp;

 import com.sun.tools.javac.util.*;

 import com.sun.tools.javac.code.*;

 import com.sun.tools.javac.code.Symbol.*;

 import com.sun.tools.javac.tree.*;

 import com.sun.tools.javac.tree.JCTree.*;

 /** Enter annotations on symbols.  Annotations accumulate in a queue,

  *  which is processed at the top level of any set of recursive calls

  *  requesting it be processed.

  *

  *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If

  *  you write code that depends on this, you do so at your own risk.

  *  This code and its internal interfaces are subject to change or

  *  deletion without notice.</b>

  */

 public class Annotate {

     protected static final Context.Key<Annotate> annotateKey =

         new Context.Key<Annotate>();

     public static Annotate instance(Context context) {

         Annotate instance = context.get(annotateKey);

         if (instance == null)

             instance = new Annotate(context);

         return instance;

     }

     final Attr attr;

     final TreeMaker make;

     final Log log;

     final Symtab syms;

     final Names names;

     final Resolve rs;

     final Types types;

     final ConstFold cfolder;

     final Check chk;

     protected Annotate(Context context) {

         context.put(annotateKey, this);

         attr = Attr.instance(context);

         make = TreeMaker.instance(context);

         log = Log.instance(context);

         syms = Symtab.instance(context);

         names = Names.instance(context);

         rs = Resolve.instance(context);

         types = Types.instance(context);

         cfolder = ConstFold.instance(context);

         chk = Check.instance(context);

     }

 /* ********************************************************************

  * Queue maintenance

  *********************************************************************/

     private int enterCount = 0;

     ListBuffer<Annotator> q = new ListBuffer<Annotator>();

     public void later(Annotator a) {

         q.append(a);

     }

     public void earlier(Annotator a) {

         q.prepend(a);

     }

     /** Called when the Enter phase starts. */

     public void enterStart() {

         enterCount++;

     }

     /** Called after the Enter phase completes. */

     public void enterDone() {

         enterCount--;

         flush();

     }

     public void flush() {

         if (enterCount != 0) return;

         enterCount++;

         try {

             while (q.nonEmpty())

                 q.next().enterAnnotation();

         } finally {

             enterCount--;

         }

     }

     /** A client that has annotations to add registers an annotator,

      *  the method it will use to add the annotation.  There are no

      *  parameters; any needed data should be captured by the

      *  Annotator.

      */

     public interface Annotator {

         void enterAnnotation();

         String toString();

     }

 /* ********************************************************************

  * Compute an attribute from its annotation.

  *********************************************************************/

     /** Process a single compound annotation, returning its

      *  Attribute. Used from MemberEnter for attaching the attributes

      *  to the annotated symbol.

      */

     Attribute.Compound enterAnnotation(JCAnnotation a,

                                        Type expected,

                                        Env<AttrContext> env) {

         // The annotation might have had its type attributed (but not checked)

         // by attr.attribAnnotationTypes during MemberEnter, in which case we do not

         // need to do it again.

         Type at = (a.annotationType.type != null ? a.annotationType.type

                   : attr.attribType(a.annotationType, env));

         a.type = chk.checkType(a.annotationType.pos(), at, expected);

         if (a.type.isErroneous())

             return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());

         if ((a.type.tsym.flags() & Flags.ANNOTATION) == 0) {

             log.error(a.annotationType.pos(),

                       "not.annotation.type", a.type.toString());

             return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil());

         }

         List<JCExpression> args = a.args;

         if (args.length() == 1 && args.head.getTag() != JCTree.ASSIGN) {

             // special case: elided "value=" assumed

             args.head = make.at(args.head.pos).

                 Assign(make.Ident(names.value), args.head);

         }

         ListBuffer<Pair<MethodSymbol,Attribute>> buf =

             new ListBuffer<Pair<MethodSymbol,Attribute>>();

         for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) {

             JCExpression t = tl.head;

             if (t.getTag() != JCTree.ASSIGN) {

                 log.error(t.pos(), "annotation.value.must.be.name.value");

                 continue;

             }

             JCAssign assign = (JCAssign)t;

             if (assign.lhs.getTag() != JCTree.IDENT) {

                 log.error(t.pos(), "annotation.value.must.be.name.value");

                 continue;

             }

             JCIdent left = (JCIdent)assign.lhs;

             Symbol method = rs.resolveQualifiedMethod(left.pos(),

                                                       env,

                                                       a.type,

                                                       left.name,

                                                       List.<Type>nil(),

                                                       null);

             left.sym = method;

             left.type = method.type;

             if (method.owner != a.type.tsym)

                 log.error(left.pos(), "no.annotation.member", left.name, a.type);

             Type result = method.type.getReturnType();

             Attribute value = enterAttributeValue(result, assign.rhs, env);

             if (!method.type.isErroneous())

                 buf.append(new Pair<MethodSymbol,Attribute>

                            ((MethodSymbol)method, value));

         }

         return new Attribute.Compound(a.type, buf.toList());

     }

     Attribute enterAttributeValue(Type expected,

                                   JCExpression tree,

                                   Env<AttrContext> env) {

         if (expected.isPrimitive() || types.isSameType(expected, syms.stringType)) {

             Type result = attr.attribExpr(tree, env, expected);

             if (result.isErroneous())

                 return new Attribute.Error(expected);

             if (result.constValue() == null) {

                 log.error(tree.pos(), "attribute.value.must.be.constant");

                 return new Attribute.Error(expected);

             }

             result = cfolder.coerce(result, expected);

             return new Attribute.Constant(expected, result.constValue());

         }

         if (expected.tsym == syms.classType.tsym) {

             Type result = attr.attribExpr(tree, env, expected);

             if (result.isErroneous())

                 return new Attribute.Error(expected);

             if (TreeInfo.name(tree) != names._class) {

                 log.error(tree.pos(), "annotation.value.must.be.class.literal");

                 return new Attribute.Error(expected);

             }

             return new Attribute.Class(types,

                                        (((JCFieldAccess) tree).selected).type);

         }

         if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) {

             if (tree.getTag() != JCTree.ANNOTATION) {

                 log.error(tree.pos(), "annotation.value.must.be.annotation");

                 expected = syms.errorType;

             }

             return enterAnnotation((JCAnnotation)tree, expected, env);

         }

         if (expected.tag == TypeTags.ARRAY) { // should really be isArray()

             if (tree.getTag() != JCTree.NEWARRAY) {

                 tree = make.at(tree.pos).

                     NewArray(null, List.<JCExpression>nil(), List.of(tree));

             }

             JCNewArray na = (JCNewArray)tree;

             if (na.elemtype != null) {

                 log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");

                 return new Attribute.Error(expected);

             }

             ListBuffer<Attribute> buf = new ListBuffer<Attribute>();

             for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {

                 buf.append(enterAttributeValue(types.elemtype(expected),

                                                l.head,

                                                env));

             }

             return new Attribute.

                 Array(expected, buf.toArray(new Attribute[buf.length()]));

         }

         if (expected.tag == TypeTags.CLASS &&

             (expected.tsym.flags() & Flags.ENUM) != 0) {

             attr.attribExpr(tree, env, expected);

             Symbol sym = TreeInfo.symbol(tree);

             if (sym == null ||

                 TreeInfo.nonstaticSelect(tree) ||

                 sym.kind != Kinds.VAR ||

                 (sym.flags() & Flags.ENUM) == 0) {

                 log.error(tree.pos(), "enum.annotation.must.be.enum.constant");

                 return new Attribute.Error(expected);

             }

             VarSymbol enumerator = (VarSymbol) sym;

             return new Attribute.Enum(expected, enumerator);

         }

         if (!expected.isErroneous())

             log.error(tree.pos(), "annotation.value.not.allowable.type");

         return new Attribute.Error(attr.attribExpr(tree, env, expected));

     }

 }