001 /*
002 * Copyright 2010-2013 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.jet.codegen;
018
019 import com.intellij.psi.PsiElement;
020 import org.jetbrains.annotations.NotNull;
021 import org.jetbrains.annotations.Nullable;
022 import org.jetbrains.asm4.AnnotationVisitor;
023 import org.jetbrains.asm4.ClassVisitor;
024 import org.jetbrains.asm4.FieldVisitor;
025 import org.jetbrains.asm4.MethodVisitor;
026 import org.jetbrains.jet.codegen.state.JetTypeMapper;
027 import org.jetbrains.jet.lang.descriptors.*;
028 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
029 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor;
030 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
031 import org.jetbrains.jet.lang.psi.JetAnnotationEntry;
032 import org.jetbrains.jet.lang.psi.JetClass;
033 import org.jetbrains.jet.lang.psi.JetModifierList;
034 import org.jetbrains.jet.lang.psi.JetModifierListOwner;
035 import org.jetbrains.jet.lang.resolve.BindingContext;
036 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
037 import org.jetbrains.jet.lang.resolve.constants.*;
038 import org.jetbrains.jet.lang.resolve.constants.StringValue;
039 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
040
041 import java.lang.annotation.RetentionPolicy;
042 import java.util.List;
043 import java.util.Map;
044
045 import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDeclaration;
046
047 public abstract class AnnotationCodegen {
048 private final JetTypeMapper typeMapper;
049 private final BindingContext bindingContext;
050
051 private AnnotationCodegen(JetTypeMapper mapper) {
052 typeMapper = mapper;
053 bindingContext = typeMapper.getBindingContext();
054 }
055
056 public void genAnnotations(Annotated annotated) {
057 if (annotated == null) {
058 return;
059 }
060
061 if (!(annotated instanceof DeclarationDescriptor)) {
062 return;
063 }
064
065 PsiElement psiElement = descriptorToDeclaration(bindingContext, (DeclarationDescriptor) annotated);
066
067 JetModifierList modifierList = null;
068 if (annotated instanceof ConstructorDescriptor && psiElement instanceof JetClass) {
069 modifierList = ((JetClass) psiElement).getPrimaryConstructorModifierList();
070 }
071 else if (psiElement instanceof JetModifierListOwner) {
072 modifierList = ((JetModifierListOwner) psiElement).getModifierList();
073 }
074
075 if (modifierList == null) {
076 return;
077 }
078
079 List<JetAnnotationEntry> annotationEntries = modifierList.getAnnotationEntries();
080 for (JetAnnotationEntry annotationEntry : annotationEntries) {
081 ResolvedCall<? extends CallableDescriptor> resolvedCall =
082 bindingContext.get(BindingContext.RESOLVED_CALL, annotationEntry.getCalleeExpression());
083 if (resolvedCall == null) continue; // Skipping annotations if they are not resolved. Needed for JetLightClass generation
084
085 AnnotationDescriptor annotationDescriptor = bindingContext.get(BindingContext.ANNOTATION, annotationEntry);
086 if (annotationDescriptor == null) continue; // Skipping annotations if they are not resolved. Needed for JetLightClass generation
087 if (isVolatile(annotationDescriptor)) continue;
088
089 genAnnotation(annotationDescriptor);
090 }
091 }
092
093 private static boolean isVolatile(@NotNull AnnotationDescriptor annotationDescriptor) {
094 ClassifierDescriptor classDescriptor = annotationDescriptor.getType().getConstructor().getDeclarationDescriptor();
095 return KotlinBuiltIns.getInstance().getVolatileAnnotationClass().equals(classDescriptor);
096 }
097
098 public void generateAnnotationDefaultValue(CompileTimeConstant value) {
099 AnnotationVisitor visitor = visitAnnotation(null, false); // Parameters are unimportant
100 genCompileTimeValue(null, value, visitor);
101 visitor.visitEnd();
102 }
103
104 private void genAnnotation(AnnotationDescriptor annotationDescriptor) {
105 ClassifierDescriptor classifierDescriptor = annotationDescriptor.getType().getConstructor().getDeclarationDescriptor();
106 RetentionPolicy rp = getRetentionPolicy(classifierDescriptor, typeMapper);
107 if (rp == RetentionPolicy.SOURCE) {
108 return;
109 }
110
111 String internalName = typeMapper.mapType(annotationDescriptor.getType()).getDescriptor();
112 AnnotationVisitor annotationVisitor = visitAnnotation(internalName, rp == RetentionPolicy.RUNTIME);
113
114 genAnnotationArguments(annotationDescriptor, annotationVisitor);
115 annotationVisitor.visitEnd();
116 }
117
118 private void genAnnotationArguments(AnnotationDescriptor annotationDescriptor, AnnotationVisitor annotationVisitor) {
119 for (Map.Entry<ValueParameterDescriptor, CompileTimeConstant<?>> entry : annotationDescriptor.getAllValueArguments().entrySet()) {
120 ValueParameterDescriptor descriptor = entry.getKey();
121 String name = descriptor.getName().asString();
122 genCompileTimeValue(name, entry.getValue(), annotationVisitor);
123 }
124 }
125
126 private void genCompileTimeValue(
127 @Nullable final String name,
128 @NotNull CompileTimeConstant<?> value,
129 @NotNull final AnnotationVisitor annotationVisitor
130 ) {
131 AnnotationArgumentVisitor argumentVisitor = new AnnotationArgumentVisitor<Void, Void>() {
132 @Override
133 public Void visitLongValue(@NotNull LongValue value, Void data) {
134 return visitSimpleValue(value);
135 }
136
137 @Override
138 public Void visitIntValue(IntValue value, Void data) {
139 return visitSimpleValue(value);
140 }
141
142 @Override
143 public Void visitShortValue(ShortValue value, Void data) {
144 return visitSimpleValue(value);
145 }
146
147 @Override
148 public Void visitByteValue(ByteValue value, Void data) {
149 return visitSimpleValue(value);
150 }
151
152 @Override
153 public Void visitDoubleValue(DoubleValue value, Void data) {
154 return visitSimpleValue(value);
155 }
156
157 @Override
158 public Void visitFloatValue(FloatValue value, Void data) {
159 return visitSimpleValue(value);
160 }
161
162 @Override
163 public Void visitBooleanValue(BooleanValue value, Void data) {
164 return visitSimpleValue(value);
165 }
166
167 @Override
168 public Void visitCharValue(CharValue value, Void data) {
169 return visitSimpleValue(value);
170 }
171
172 @Override
173 public Void visitStringValue(StringValue value, Void data) {
174 return visitSimpleValue(value);
175 }
176
177 @Override
178 public Void visitEnumValue(EnumValue value, Void data) {
179 String propertyName = value.getValue().getName().asString();
180 annotationVisitor.visitEnum(name, typeMapper.mapType(value.getType(KotlinBuiltIns.getInstance())).getDescriptor(), propertyName);
181 return null;
182 }
183
184 @Override
185 public Void visitArrayValue(ArrayValue value, Void data) {
186 AnnotationVisitor visitor = annotationVisitor.visitArray(name);
187 for (CompileTimeConstant<?> argument : value.getValue()) {
188 genCompileTimeValue(null, argument, visitor);
189 }
190 visitor.visitEnd();
191 return null;
192 }
193
194 @Override
195 public Void visitAnnotationValue(AnnotationValue value, Void data) {
196 String internalAnnName = typeMapper.mapType(value.getValue().getType()).getDescriptor();
197 AnnotationVisitor visitor = annotationVisitor.visitAnnotation(name, internalAnnName);
198 genAnnotationArguments(value.getValue(), visitor);
199 visitor.visitEnd();
200 return null;
201 }
202
203 @Override
204 public Void visitJavaClassValue(JavaClassValue value, Void data) {
205 annotationVisitor.visit(name, typeMapper.mapType(value.getValue()));
206 return null;
207 }
208
209 private Void visitSimpleValue(CompileTimeConstant value) {
210 annotationVisitor.visit(name, value.getValue());
211 return null;
212 }
213
214 @Override
215 public Void visitErrorValue(ErrorValue value, Void data) {
216 return visitUnsupportedValue(value);
217 }
218
219 @Override
220 public Void visitNullValue(NullValue value, Void data) {
221 return visitUnsupportedValue(value);
222 }
223
224 private Void visitUnsupportedValue(CompileTimeConstant value) {
225 throw new IllegalStateException("Don't know how to compile annotation value " + value);
226 }
227 };
228
229 value.accept(argumentVisitor, null);
230 }
231
232 private static RetentionPolicy getRetentionPolicy(ClassifierDescriptor descriptor, JetTypeMapper typeMapper) {
233 for (AnnotationDescriptor annotationDescriptor : descriptor.getAnnotations()) {
234 String internalName = typeMapper.mapType(annotationDescriptor.getType()).getInternalName();
235 if("java/lang/annotation/Retention".equals(internalName)) {
236 CompileTimeConstant<?> compileTimeConstant = annotationDescriptor.getAllValueArguments().values().iterator().next();
237 assert compileTimeConstant instanceof EnumValue : "Retention argument should be Enum value " + compileTimeConstant;
238 PropertyDescriptor propertyDescriptor = ((EnumValue) compileTimeConstant).getValue();
239 assert "java/lang/annotation/RetentionPolicy".equals(typeMapper.mapType(propertyDescriptor.getType()).getInternalName()) :
240 "Retention argument should be of type RetentionPolicy";
241 String propertyDescriptorName = propertyDescriptor.getName().asString();
242 return RetentionPolicy.valueOf(propertyDescriptorName);
243 }
244 }
245
246 return RetentionPolicy.CLASS;
247 }
248
249 abstract AnnotationVisitor visitAnnotation(String descr, boolean visible);
250
251 public static AnnotationCodegen forClass(final ClassVisitor cv, JetTypeMapper mapper) {
252 return new AnnotationCodegen(mapper) {
253 @Override
254 AnnotationVisitor visitAnnotation(String descr, boolean visible) {
255 return cv.visitAnnotation(descr, visible);
256 }
257 };
258 }
259
260 public static AnnotationCodegen forMethod(final MethodVisitor mv, JetTypeMapper mapper) {
261 return new AnnotationCodegen(mapper) {
262 @Override
263 AnnotationVisitor visitAnnotation(String descr, boolean visible) {
264 return mv.visitAnnotation(descr, visible);
265 }
266 };
267 }
268
269 public static AnnotationCodegen forField(final FieldVisitor fv, JetTypeMapper mapper) {
270 return new AnnotationCodegen(mapper) {
271 @Override
272 AnnotationVisitor visitAnnotation(String descr, boolean visible) {
273 return fv.visitAnnotation(descr, visible);
274 }
275 };
276 }
277
278 public static AnnotationCodegen forParameter(final int parameter, final MethodVisitor mv, JetTypeMapper mapper) {
279 return new AnnotationCodegen(mapper) {
280 @Override
281 AnnotationVisitor visitAnnotation(String descr, boolean visible) {
282 return mv.visitParameterAnnotation(parameter, descr, visible);
283 }
284 };
285 }
286
287 public static AnnotationCodegen forAnnotationDefaultValue(final MethodVisitor mv, JetTypeMapper mapper) {
288 return new AnnotationCodegen(mapper) {
289 @Override
290 AnnotationVisitor visitAnnotation(String descr, boolean visible) {
291 return mv.visitAnnotationDefault();
292 }
293 };
294 }
295 }