1 /* 2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.tools.javac.code; 27 28 import java.util.LinkedHashMap; 29 import java.util.Map; 30 import javax.lang.model.element.AnnotationMirror; 31 import javax.lang.model.element.AnnotationValue; 32 import javax.lang.model.element.AnnotationValueVisitor; 33 import javax.lang.model.type.DeclaredType; 34 import com.sun.tools.javac.code.Symbol; 35 import com.sun.tools.javac.util; 36 37 import static com.sun.tools.javac.code.TypeTags.*; 38 39 /** An annotation value. 40 * 41 * <p><b>This is NOT part of any supported API. 42 * If you write code that depends on this, you do so at your own risk. 43 * This code and its internal interfaces are subject to change or 44 * deletion without notice.</b> 45 */ 46 public abstract class Attribute implements AnnotationValue { 47 48 /** The type of the annotation element. */ 49 public Type type; 50 51 public Attribute(Type type) { 52 this.type = type; 53 } 54 55 public abstract void accept(Visitor v); 56 57 public Object getValue() { 58 throw new UnsupportedOperationException(); 59 } 60 61 public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) { 62 throw new UnsupportedOperationException(); 63 } 64 65 66 /** The value for an annotation element of primitive type or String. */ 67 public static class Constant extends Attribute { 68 public final Object value; 69 public void accept(Visitor v) { v.visitConstant(this); } 70 public Constant(Type type, Object value) { 71 super(type); 72 this.value = value; 73 } 74 public String toString() { 75 return Constants.format(value, type); 76 } 77 public Object getValue() { 78 return Constants.decode(value, type); 79 } 80 public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) { 81 if (value instanceof String) 82 return v.visitString((String) value, p); 83 if (value instanceof Integer) { 84 int i = (Integer) value; 85 switch (type.tag) { 86 case BOOLEAN: return v.visitBoolean(i != 0, p); 87 case CHAR: return v.visitChar((char) i, p); 88 case BYTE: return v.visitByte((byte) i, p); 89 case SHORT: return v.visitShort((short) i, p); 90 case INT: return v.visitInt(i, p); 91 } 92 } 93 switch (type.tag) { 94 case LONG: return v.visitLong((Long) value, p); 95 case FLOAT: return v.visitFloat((Float) value, p); 96 case DOUBLE: return v.visitDouble((Double) value, p); 97 } 98 throw new AssertionError("Bad annotation element value: " + value); 99 } 100 } 101 102 /** The value for an annotation element of type java.lang.Class, 103 * represented as a ClassSymbol. 104 */ 105 public static class Class extends Attribute { 106 public final Type type; 107 public void accept(Visitor v) { v.visitClass(this); } 108 public Class(Types types, Type type) { 109 super(makeClassType(types, type)); 110 this.type = type; 111 } 112 static Type makeClassType(Types types, Type type) { 113 Type arg = type.isPrimitive() 114 ? types.boxedClass(type).type 115 : types.erasure(type); 116 return new Type.ClassType(types.syms.classType.getEnclosingType(), 117 List.of(arg), 118 types.syms.classType.tsym); 119 } 120 public String toString() { 121 return type + ".class"; 122 } 123 public Type getValue() { 124 return type; 125 } 126 public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) { 127 return v.visitType(type, p); 128 } 129 } 130 131 /** A compound annotation element value, the type of which is an 132 * attribute interface. 133 */ 134 public static class Compound extends Attribute implements AnnotationMirror { 135 /** The attributes values, as pairs. Each pair contains a 136 * reference to the accessing method in the attribute interface 137 * and the value to be returned when that method is called to 138 * access this attribute. 139 */ 140 public final List<Pair<MethodSymbol,Attribute>> values; 141 public Compound(Type type, 142 List<Pair<MethodSymbol,Attribute>> values) { 143 super(type); 144 this.values = values; 145 } 146 public void accept(Visitor v) { v.visitCompound(this); } 147 148 /** 149 * Returns a string representation of this annotation. 150 * String is of one of the forms: 151 * @com.example.foo(name1=val1, name2=val2) 152 * @com.example.foo(val) 153 * @com.example.foo 154 * Omit parens for marker annotations, and omit "value=" when allowed. 155 */ 156 public String toString() { 157 StringBuilder buf = new StringBuilder(); 158 buf.append("@"); 159 buf.append(type); 160 int len = values.length(); 161 if (len > 0) { 162 buf.append('('); 163 boolean first = true; 164 for (Pair<MethodSymbol, Attribute> value : values) { 165 if (!first) buf.append(", "); 166 first = false; 167 168 Name name = value.fst.name; 169 if (len > 1 || name != name.table.names.value) { 170 buf.append(name); 171 buf.append('='); 172 } 173 buf.append(value.snd); 174 } 175 buf.append(')'); 176 } 177 return buf.toString(); 178 } 179 180 public Attribute member(Name member) { 181 for (Pair<MethodSymbol,Attribute> pair : values) 182 if (pair.fst.name == member) return pair.snd; 183 return null; 184 } 185 186 public Attribute.Compound getValue() { 187 return this; 188 } 189 190 public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) { 191 return v.visitAnnotation(this, p); 192 } 193 194 public DeclaredType getAnnotationType() { 195 return (DeclaredType) type; 196 } 197 198 public Map<MethodSymbol, Attribute> getElementValues() { 199 Map<MethodSymbol, Attribute> valmap = 200 new LinkedHashMap<MethodSymbol, Attribute>(); 201 for (Pair<MethodSymbol, Attribute> value : values) 202 valmap.put(value.fst, value.snd); 203 return valmap; 204 } 205 } 206 207 /** The value for an annotation element of an array type. 208 */ 209 public static class Array extends Attribute { 210 public final Attribute[] values; 211 public Array(Type type, Attribute[] values) { 212 super(type); 213 this.values = values; 214 } 215 public void accept(Visitor v) { v.visitArray(this); } 216 public String toString() { 217 StringBuilder buf = new StringBuilder(); 218 buf.append('{'); 219 boolean first = true; 220 for (Attribute value : values) { 221 if (!first) 222 buf.append(", "); 223 first = false; 224 buf.append(value); 225 } 226 buf.append('}'); 227 return buf.toString(); 228 } 229 public List<Attribute> getValue() { 230 return List.from(values); 231 } 232 public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) { 233 return v.visitArray(getValue(), p); 234 } 235 } 236 237 /** The value for an annotation element of an enum type. 238 */ 239 public static class Enum extends Attribute { 240 public VarSymbol value; 241 public Enum(Type type, VarSymbol value) { 242 super(type); 243 this.value = Assert.checkNonNull(value); 244 } 245 public void accept(Visitor v) { v.visitEnum(this); } 246 public String toString() { 247 return value.enclClass() + "." + value; // qualified name 248 } 249 public VarSymbol getValue() { 250 return value; 251 } 252 public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) { 253 return v.visitEnumConstant(value, p); 254 } 255 } 256 257 public static class Error extends Attribute { 258 public Error(Type type) { 259 super(type); 260 } 261 public void accept(Visitor v) { v.visitError(this); } 262 public String toString() { 263 return "<error>"; 264 } 265 public String getValue() { 266 return toString(); 267 } 268 public <R, P> R accept(AnnotationValueVisitor<R, P> v, P p) { 269 return v.visitString(toString(), p); 270 } 271 } 272 273 /** A visitor type for dynamic dispatch on the kind of attribute value. */ 274 public static interface Visitor { 275 void visitConstant(Attribute.Constant value); 276 void visitClass(Attribute.Class clazz); 277 void visitCompound(Attribute.Compound compound); 278 void visitArray(Attribute.Array array); 279 void visitEnum(Attribute.Enum e); 280 void visitError(Attribute.Error e); 281 } 282 283 /** A mirror of java.lang.annotation.RetentionPolicy. */ 284 public static enum RetentionPolicy { 285 SOURCE, 286 CLASS, 287 RUNTIME 288 } 289 }