| 1 | /* |
| 2 | * Copyright 2003-2006 Sun Microsystems, Inc. All Rights Reserved. |
| 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 | * |
| 5 | * This code is free software; you can redistribute it and/or modify it |
| 6 | * under the terms of the GNU General Public License version 2 only, as |
| 7 | * published by the Free Software Foundation. Sun designates this |
| 8 | * particular file as subject to the "Classpath" exception as provided |
| 9 | * by Sun in the LICENSE file that accompanied this code. |
| 10 | * |
| 11 | * This code is distributed in the hope that it will be useful, but WITHOUT |
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| 14 | * version 2 for more details (a copy is included in the LICENSE file that |
| 15 | * accompanied this code). |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License version |
| 18 | * 2 along with this work; if not, write to the Free Software Foundation, |
| 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| 20 | * |
| 21 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| 22 | * CA 95054 USA or visit www.sun.com if you need additional information or |
| 23 | * have any questions. |
| 24 | */ |
| 25 | |
| 26 | package com.sun.tools.javac.comp; |
| 27 | |
| 28 | import com.sun.tools.javac.util.*; |
| 29 | import com.sun.tools.javac.code.*; |
| 30 | import com.sun.tools.javac.code.Symbol.*; |
| 31 | import com.sun.tools.javac.tree.*; |
| 32 | import com.sun.tools.javac.tree.JCTree.*; |
| 33 | |
| 34 | /** Enter annotations on symbols. Annotations accumulate in a queue, |
| 35 | * which is processed at the top level of any set of recursive calls |
| 36 | * requesting it be processed. |
| 37 | * |
| 38 | * <p><b>This is NOT part of any API supported by Sun Microsystems. If |
| 39 | * you write code that depends on this, you do so at your own risk. |
| 40 | * This code and its internal interfaces are subject to change or |
| 41 | * deletion without notice.</b> |
| 42 | */ |
| 43 | public class Annotate { |
| 44 | protected static final Context.Key<Annotate> annotateKey = |
| 45 | new Context.Key<Annotate>(); |
| 46 | |
| 47 | public static Annotate instance(Context context) { |
| 48 | Annotate instance = context.get(annotateKey); |
| 49 | if (instance == null) |
| 50 | instance = new Annotate(context); |
| 51 | return instance; |
| 52 | } |
| 53 | |
| 54 | final Attr attr; |
| 55 | final TreeMaker make; |
| 56 | final Log log; |
| 57 | final Symtab syms; |
| 58 | final Name.Table names; |
| 59 | final Resolve rs; |
| 60 | final Types types; |
| 61 | final ConstFold cfolder; |
| 62 | final Check chk; |
| 63 | |
| 64 | protected Annotate(Context context) { |
| 65 | context.put(annotateKey, this); |
| 66 | attr = Attr.instance(context); |
| 67 | make = TreeMaker.instance(context); |
| 68 | log = Log.instance(context); |
| 69 | syms = Symtab.instance(context); |
| 70 | names = Name.Table.instance(context); |
| 71 | rs = Resolve.instance(context); |
| 72 | types = Types.instance(context); |
| 73 | cfolder = ConstFold.instance(context); |
| 74 | chk = Check.instance(context); |
| 75 | } |
| 76 | |
| 77 | /* ******************************************************************** |
| 78 | * Queue maintenance |
| 79 | *********************************************************************/ |
| 80 | |
| 81 | private int enterCount = 0; |
| 82 | |
| 83 | ListBuffer<Annotator> q = new ListBuffer<Annotator>(); |
| 84 | |
| 85 | public void later(Annotator a) { |
| 86 | q.append(a); |
| 87 | } |
| 88 | |
| 89 | public void earlier(Annotator a) { |
| 90 | q.prepend(a); |
| 91 | } |
| 92 | |
| 93 | /** Called when the Enter phase starts. */ |
| 94 | public void enterStart() { |
| 95 | enterCount++; |
| 96 | } |
| 97 | |
| 98 | /** Called after the Enter phase completes. */ |
| 99 | public void enterDone() { |
| 100 | enterCount--; |
| 101 | flush(); |
| 102 | } |
| 103 | |
| 104 | public void flush() { |
| 105 | if (enterCount != 0) return; |
| 106 | enterCount++; |
| 107 | try { |
| 108 | while (q.nonEmpty()) |
| 109 | q.next().enterAnnotation(); |
| 110 | } finally { |
| 111 | enterCount--; |
| 112 | } |
| 113 | } |
| 114 | |
| 115 | /** A client that has annotations to add registers an annotator, |
| 116 | * the method it will use to add the annotation. There are no |
| 117 | * parameters; any needed data should be captured by the |
| 118 | * Annotator. |
| 119 | */ |
| 120 | public interface Annotator { |
| 121 | void enterAnnotation(); |
| 122 | String toString(); |
| 123 | } |
| 124 | |
| 125 | |
| 126 | /* ******************************************************************** |
| 127 | * Compute an attribute from its annotation. |
| 128 | *********************************************************************/ |
| 129 | |
| 130 | /** Process a single compound annotation, returning its |
| 131 | * Attribute. Used from MemberEnter for attaching the attributes |
| 132 | * to the annotated symbol. |
| 133 | */ |
| 134 | Attribute.Compound enterAnnotation(JCAnnotation a, |
| 135 | Type expected, |
| 136 | Env<AttrContext> env) { |
| 137 | // The annotation might have had its type attributed (but not checked) |
| 138 | // by attr.attribAnnotationTypes during MemberEnter, in which case we do not |
| 139 | // need to do it again. |
| 140 | Type at = (a.annotationType.type != null ? a.annotationType.type |
| 141 | : attr.attribType(a.annotationType, env)); |
| 142 | a.type = chk.checkType(a.annotationType.pos(), at, expected); |
| 143 | if (a.type.isErroneous()) |
| 144 | return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil()); |
| 145 | if ((a.type.tsym.flags() & Flags.ANNOTATION) == 0) { |
| 146 | log.error(a.annotationType.pos(), |
| 147 | "not.annotation.type", a.type.toString()); |
| 148 | return new Attribute.Compound(a.type, List.<Pair<MethodSymbol,Attribute>>nil()); |
| 149 | } |
| 150 | List<JCExpression> args = a.args; |
| 151 | if (args.length() == 1 && args.head.getTag() != JCTree.ASSIGN) { |
| 152 | // special case: elided "value=" assumed |
| 153 | args.head = make.at(args.head.pos). |
| 154 | Assign(make.Ident(names.value), args.head); |
| 155 | } |
| 156 | ListBuffer<Pair<MethodSymbol,Attribute>> buf = |
| 157 | new ListBuffer<Pair<MethodSymbol,Attribute>>(); |
| 158 | for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) { |
| 159 | JCExpression t = tl.head; |
| 160 | if (t.getTag() != JCTree.ASSIGN) { |
| 161 | log.error(t.pos(), "annotation.value.must.be.name.value"); |
| 162 | continue; |
| 163 | } |
| 164 | JCAssign assign = (JCAssign)t; |
| 165 | if (assign.lhs.getTag() != JCTree.IDENT) { |
| 166 | log.error(t.pos(), "annotation.value.must.be.name.value"); |
| 167 | continue; |
| 168 | } |
| 169 | JCIdent left = (JCIdent)assign.lhs; |
| 170 | Symbol method = rs.resolveQualifiedMethod(left.pos(), |
| 171 | env, |
| 172 | a.type, |
| 173 | left.name, |
| 174 | List.<Type>nil(), |
| 175 | null); |
| 176 | left.sym = method; |
| 177 | left.type = method.type; |
| 178 | if (method.owner != a.type.tsym) |
| 179 | log.error(left.pos(), "no.annotation.member", left.name, a.type); |
| 180 | Type result = method.type.getReturnType(); |
| 181 | Attribute value = enterAttributeValue(result, assign.rhs, env); |
| 182 | if (!method.type.isErroneous()) |
| 183 | buf.append(new Pair<MethodSymbol,Attribute> |
| 184 | ((MethodSymbol)method, value)); |
| 185 | } |
| 186 | return new Attribute.Compound(a.type, buf.toList()); |
| 187 | } |
| 188 | |
| 189 | Attribute enterAttributeValue(Type expected, |
| 190 | JCExpression tree, |
| 191 | Env<AttrContext> env) { |
| 192 | if (expected.isPrimitive() || types.isSameType(expected, syms.stringType)) { |
| 193 | Type result = attr.attribExpr(tree, env, expected); |
| 194 | if (result.isErroneous()) |
| 195 | return new Attribute.Error(expected); |
| 196 | if (result.constValue() == null) { |
| 197 | log.error(tree.pos(), "attribute.value.must.be.constant"); |
| 198 | return new Attribute.Error(expected); |
| 199 | } |
| 200 | result = cfolder.coerce(result, expected); |
| 201 | return new Attribute.Constant(expected, result.constValue()); |
| 202 | } |
| 203 | if (expected.tsym == syms.classType.tsym) { |
| 204 | Type result = attr.attribExpr(tree, env, expected); |
| 205 | if (result.isErroneous()) |
| 206 | return new Attribute.Error(expected); |
| 207 | if (TreeInfo.name(tree) != names._class) { |
| 208 | log.error(tree.pos(), "annotation.value.must.be.class.literal"); |
| 209 | return new Attribute.Error(expected); |
| 210 | } |
| 211 | return new Attribute.Class(types, |
| 212 | (((JCFieldAccess) tree).selected).type); |
| 213 | } |
| 214 | if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) { |
| 215 | if (tree.getTag() != JCTree.ANNOTATION) { |
| 216 | log.error(tree.pos(), "annotation.value.must.be.annotation"); |
| 217 | expected = syms.errorType; |
| 218 | } |
| 219 | return enterAnnotation((JCAnnotation)tree, expected, env); |
| 220 | } |
| 221 | if (expected.tag == TypeTags.ARRAY) { // should really be isArray() |
| 222 | if (tree.getTag() != JCTree.NEWARRAY) { |
| 223 | tree = make.at(tree.pos). |
| 224 | NewArray(null, List.<JCExpression>nil(), List.of(tree)); |
| 225 | } |
| 226 | JCNewArray na = (JCNewArray)tree; |
| 227 | if (na.elemtype != null) { |
| 228 | log.error(na.elemtype.pos(), "new.not.allowed.in.annotation"); |
| 229 | return new Attribute.Error(expected); |
| 230 | } |
| 231 | ListBuffer<Attribute> buf = new ListBuffer<Attribute>(); |
| 232 | for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) { |
| 233 | buf.append(enterAttributeValue(types.elemtype(expected), |
| 234 | l.head, |
| 235 | env)); |
| 236 | } |
| 237 | return new Attribute. |
| 238 | Array(expected, buf.toArray(new Attribute[buf.length()])); |
| 239 | } |
| 240 | if (expected.tag == TypeTags.CLASS && |
| 241 | (expected.tsym.flags() & Flags.ENUM) != 0) { |
| 242 | attr.attribExpr(tree, env, expected); |
| 243 | Symbol sym = TreeInfo.symbol(tree); |
| 244 | if (sym == null || |
| 245 | TreeInfo.nonstaticSelect(tree) || |
| 246 | sym.kind != Kinds.VAR || |
| 247 | (sym.flags() & Flags.ENUM) == 0) { |
| 248 | log.error(tree.pos(), "enum.annotation.must.be.enum.constant"); |
| 249 | return new Attribute.Error(expected); |
| 250 | } |
| 251 | VarSymbol enumerator = (VarSymbol) sym; |
| 252 | return new Attribute.Enum(expected, enumerator); |
| 253 | } |
| 254 | if (!expected.isErroneous()) |
| 255 | log.error(tree.pos(), "annotation.value.not.allowable.type"); |
| 256 | return new Attribute.Error(attr.attribExpr(tree, env, expected)); |
| 257 | } |
| 258 | } |