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.openapi.progress.ProcessCanceledException;
020 import com.intellij.psi.PsiElement;
021 import org.jetbrains.annotations.NotNull;
022 import org.jetbrains.annotations.Nullable;
023 import org.jetbrains.asm4.AnnotationVisitor;
024 import org.jetbrains.asm4.Label;
025 import org.jetbrains.asm4.MethodVisitor;
026 import org.jetbrains.asm4.Type;
027 import org.jetbrains.asm4.commons.InstructionAdapter;
028 import org.jetbrains.asm4.commons.Method;
029 import org.jetbrains.jet.codegen.binding.CodegenBinding;
030 import org.jetbrains.jet.codegen.context.CodegenContext;
031 import org.jetbrains.jet.codegen.context.MethodContext;
032 import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
033 import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature;
034 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
035 import org.jetbrains.jet.codegen.signature.JvmPropertyAccessorSignature;
036 import org.jetbrains.jet.codegen.signature.kotlin.JetMethodAnnotationWriter;
037 import org.jetbrains.jet.codegen.signature.kotlin.JetValueParameterAnnotationWriter;
038 import org.jetbrains.jet.codegen.state.GenerationState;
039 import org.jetbrains.jet.codegen.state.GenerationStateAware;
040 import org.jetbrains.jet.codegen.state.JetTypeMapper;
041 import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
042 import org.jetbrains.jet.lang.descriptors.*;
043 import org.jetbrains.jet.lang.psi.JetNamedFunction;
044 import org.jetbrains.jet.lang.resolve.BindingContext;
045 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
046 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
047 import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
048 import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils;
049 import org.jetbrains.jet.lang.resolve.name.Name;
050
051 import java.util.*;
052
053 import static org.jetbrains.asm4.Opcodes.*;
054 import static org.jetbrains.jet.codegen.AsmUtil.*;
055 import static org.jetbrains.jet.codegen.CodegenUtil.*;
056 import static org.jetbrains.jet.codegen.binding.CodegenBinding.isLocalNamedFun;
057 import static org.jetbrains.jet.lang.resolve.BindingContextUtils.callableDescriptorToDeclaration;
058 import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDeclaration;
059 import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isFunctionLiteral;
060 import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE;
061
062 public class FunctionCodegen extends GenerationStateAware {
063 private final CodegenContext owner;
064 private final ClassBuilder v;
065
066 public FunctionCodegen(CodegenContext owner, ClassBuilder v, GenerationState state) {
067 super(state);
068 this.owner = owner;
069 this.v = v;
070 }
071
072 public void gen(@NotNull JetNamedFunction function) {
073 SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, function);
074 assert functionDescriptor != null;
075
076 OwnerKind kind = owner.getContextKind();
077 JvmMethodSignature method = typeMapper.mapSignature(functionDescriptor, true, kind);
078
079 if (kind != OwnerKind.TRAIT_IMPL || function.getBodyExpression() != null) {
080 boolean needJetAnnotations = kind != OwnerKind.TRAIT_IMPL;
081 generateMethod(function, method, needJetAnnotations, functionDescriptor,
082 new FunctionGenerationStrategy.FunctionDefault(state, functionDescriptor, function));
083 }
084
085 generateDefaultIfNeeded(owner.intoFunction(functionDescriptor), state, v, method, functionDescriptor, kind,
086 DefaultParameterValueLoader.DEFAULT);
087 }
088
089 public void generateMethod(
090 @Nullable PsiElement origin,
091 @NotNull JvmMethodSignature jvmSignature,
092 boolean needJetAnnotations,
093 @NotNull FunctionDescriptor functionDescriptor,
094 @NotNull FunctionGenerationStrategy strategy
095 ) {
096 generateMethod(origin, jvmSignature, needJetAnnotations, functionDescriptor, owner.intoFunction(functionDescriptor), strategy);
097 }
098
099 public void generateMethod(
100 @Nullable PsiElement origin,
101 @NotNull JvmMethodSignature jvmSignature,
102 boolean needJetAnnotations,
103 @NotNull FunctionDescriptor functionDescriptor,
104 @NotNull MethodContext methodContext,
105 @NotNull FunctionGenerationStrategy strategy
106 ) {
107
108 Method asmMethod = jvmSignature.getAsmMethod();
109
110 MethodVisitor mv = v.newMethod(origin,
111 getMethodAsmFlags(functionDescriptor, methodContext.getContextKind()),
112 asmMethod.getName(),
113 asmMethod.getDescriptor(),
114 jvmSignature.getGenericsSignature(),
115 null);
116
117 AnnotationCodegen.forMethod(mv, typeMapper).genAnnotations(functionDescriptor);
118 if (state.getClassBuilderMode() == ClassBuilderMode.SIGNATURES) return;
119
120 if (needJetAnnotations) {
121 genJetAnnotations(mv, functionDescriptor, jvmSignature);
122 }
123
124 if (isAbstractMethod(functionDescriptor, methodContext.getContextKind())) return;
125
126 if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
127 genStubCode(mv);
128 return;
129 }
130
131 generateMethodBody(mv, functionDescriptor, methodContext, jvmSignature, strategy);
132
133 endVisit(mv, null, origin);
134
135 generateBridgeIfNeeded(owner, state, v, jvmSignature.getAsmMethod(), functionDescriptor);
136
137 methodContext.recordSyntheticAccessorIfNeeded(functionDescriptor, typeMapper);
138 }
139
140 @Nullable
141 private Type getThisTypeForFunction(@NotNull FunctionDescriptor functionDescriptor, @NotNull MethodContext context) {
142 ReceiverParameterDescriptor expectedThisObject = functionDescriptor.getExpectedThisObject();
143 if (functionDescriptor instanceof ConstructorDescriptor) {
144 return typeMapper.mapType(functionDescriptor.getReturnType());
145 }
146 else if (expectedThisObject != null) {
147 return typeMapper.mapType(expectedThisObject.getType());
148 }
149 else if (isFunctionLiteral(functionDescriptor) || isLocalNamedFun(functionDescriptor)) {
150 return typeMapper.mapType(context.getThisDescriptor());
151 }
152 else {
153 return null;
154 }
155 }
156
157 private void generateMethodBody(
158 @NotNull MethodVisitor mv,
159 @NotNull FunctionDescriptor functionDescriptor,
160 @NotNull MethodContext context,
161 @NotNull JvmMethodSignature signature,
162 @NotNull FunctionGenerationStrategy strategy
163 ) {
164 Collection<String> localVariableNames = new HashSet<String>(getParameterNamesAsStrings(functionDescriptor));
165
166 Map<Name, Label> labelsForSharedVars = new HashMap<Name, Label>();
167
168 mv.visitCode();
169
170 Label methodBegin = new Label();
171 mv.visitLabel(methodBegin);
172
173 OwnerKind kind = context.getContextKind();
174 if (kind instanceof OwnerKind.StaticDelegateKind) {
175 generateStaticDelegateMethodBody(mv, signature.getAsmMethod(), (OwnerKind.StaticDelegateKind) kind);
176 }
177 else {
178 FrameMap frameMap = strategy.getFrameMap(typeMapper, context);
179
180 for (ValueParameterDescriptor parameter : functionDescriptor.getValueParameters()) {
181 frameMap.enter(parameter, typeMapper.mapType(parameter));
182 }
183
184 labelsForSharedVars.putAll(createSharedVarsForParameters(mv, functionDescriptor, frameMap));
185
186 if (!JetTypeMapper.isAccessor(functionDescriptor)) {
187 genNotNullAssertionsForParameters(new InstructionAdapter(mv), state, functionDescriptor, frameMap);
188 }
189
190 strategy.generateBody(mv, signature, context);
191
192 localVariableNames.addAll(strategy.getLocalVariableNames());
193 }
194
195 Label methodEnd = new Label();
196 mv.visitLabel(methodEnd);
197
198
199 Type thisType = getThisTypeForFunction(functionDescriptor, context);
200 generateLocalVariableTable(mv, signature, functionDescriptor, thisType, methodBegin, methodEnd, localVariableNames, labelsForSharedVars, kind);
201 }
202
203 @NotNull
204 private static List<String> getParameterNamesAsStrings(@NotNull FunctionDescriptor functionDescriptor) {
205 List<ValueParameterDescriptor> parameters = functionDescriptor.getValueParameters();
206 List<String> result = new ArrayList<String>(parameters.size());
207 for (ValueParameterDescriptor parameter : parameters) {
208 result.add(parameter.getName().asString());
209 }
210 return result;
211 }
212
213 private void generateLocalVariableTable(
214 @NotNull MethodVisitor mv,
215 @NotNull JvmMethodSignature jvmMethodSignature,
216 @NotNull FunctionDescriptor functionDescriptor,
217 @Nullable Type thisType,
218 @NotNull Label methodBegin,
219 @NotNull Label methodEnd,
220 @NotNull Collection<String> localVariableNames,
221 @NotNull Map<Name, Label> labelsForSharedVars,
222 @NotNull OwnerKind ownerKind
223 ) {
224 Iterator<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters().iterator();
225 List<JvmMethodParameterSignature> params = jvmMethodSignature.getKotlinParameterTypes();
226 int shift = 0;
227
228 boolean isStatic = AsmUtil.isStaticMethod(ownerKind, functionDescriptor);
229 if (!isStatic) {
230 //add this
231 if (thisType != null) {
232 mv.visitLocalVariable("this", thisType.getDescriptor(), null, methodBegin, methodEnd, shift);
233 } else {
234 //TODO: provide thisType for callable reference
235 }
236 shift++;
237 }
238
239 for (int i = 0; i < params.size(); i++) {
240 JvmMethodParameterSignature param = params.get(i);
241 JvmMethodParameterKind kind = param.getKind();
242 String parameterName = "$" + param.getKind().name().toLowerCase();
243
244 if (needIndexForVar(kind)) {
245 parameterName = parameterName + "$" + i;
246 }
247
248 Type type = param.getAsmType();
249 if (kind == JvmMethodParameterKind.VALUE) {
250 ValueParameterDescriptor parameter = valueParameters.next();
251 Label divideLabel = labelsForSharedVars.get(parameter.getName());
252 parameterName = parameter.getName().asString();
253 if (divideLabel != null) {
254 mv.visitLocalVariable(parameterName, type.getDescriptor(), null, methodBegin, divideLabel, shift);
255
256 String nameForSharedVar = createTmpVariableName(localVariableNames);
257 localVariableNames.add(nameForSharedVar);
258
259 Type sharedVarType = typeMapper.getSharedVarType(parameter);
260 mv.visitLocalVariable(nameForSharedVar, sharedVarType.getDescriptor(), null, divideLabel, methodEnd, shift);
261 shift += Math.max(type.getSize(), sharedVarType.getSize());
262 continue;
263 }
264 }
265
266 mv.visitLocalVariable(parameterName, type.getDescriptor(), null, methodBegin, methodEnd, shift);
267 shift += type.getSize();
268 }
269 }
270
271 @NotNull
272 private Map<Name, Label> createSharedVarsForParameters(
273 @NotNull MethodVisitor mv,
274 @NotNull FunctionDescriptor functionDescriptor,
275 @NotNull FrameMap frameMap
276 ) {
277 Map<Name, Label> labelsForSharedVars = new HashMap<Name, Label>();
278
279 for (ValueParameterDescriptor parameter : functionDescriptor.getValueParameters()) {
280 Type sharedVarType = typeMapper.getSharedVarType(parameter);
281 if (sharedVarType == null) {
282 continue;
283 }
284
285 Type localVarType = typeMapper.mapType(parameter);
286 int index = frameMap.getIndex(parameter);
287 mv.visitTypeInsn(NEW, sharedVarType.getInternalName());
288 mv.visitInsn(DUP);
289 mv.visitInsn(DUP);
290 mv.visitMethodInsn(INVOKESPECIAL, sharedVarType.getInternalName(), "<init>", "()V");
291 mv.visitVarInsn(localVarType.getOpcode(ILOAD), index);
292 mv.visitFieldInsn(PUTFIELD, sharedVarType.getInternalName(), "ref", StackValue.refType(localVarType).getDescriptor());
293
294 Label labelForSharedVar = new Label();
295 mv.visitLabel(labelForSharedVar);
296
297 labelsForSharedVars.put(parameter.getName(), labelForSharedVar);
298
299 mv.visitVarInsn(sharedVarType.getOpcode(ISTORE), index);
300 }
301
302 return labelsForSharedVars;
303 }
304
305 private static void generateStaticDelegateMethodBody(
306 @NotNull MethodVisitor mv,
307 @NotNull Method asmMethod,
308 @NotNull OwnerKind.StaticDelegateKind dk
309 ) {
310 InstructionAdapter iv = new InstructionAdapter(mv);
311 Type[] argTypes = asmMethod.getArgumentTypes();
312
313 // The first line of some namespace file is written to the line number attribute of a static delegate to allow to 'step into' it
314 // This is similar to what javac does with bridge methods
315 Label label = new Label();
316 iv.visitLabel(label);
317 iv.visitLineNumber(1, label);
318
319 int k = 0;
320 for (Type argType : argTypes) {
321 iv.load(k, argType);
322 k += argType.getSize();
323 }
324 iv.invokestatic(dk.getOwnerClass(), asmMethod.getName(), asmMethod.getDescriptor());
325 iv.areturn(asmMethod.getReturnType());
326 }
327
328 private void genJetAnnotations(
329 @NotNull MethodVisitor mv,
330 @NotNull FunctionDescriptor functionDescriptor,
331 @NotNull JvmMethodSignature jvmSignature
332 ) {
333
334 if (functionDescriptor instanceof PropertyAccessorDescriptor) {
335 assert jvmSignature instanceof JvmPropertyAccessorSignature : "jvmSignature for property should have JvmPropertyAccessorSignature type";
336 PropertyCodegen.generateJetPropertyAnnotation(mv, (JvmPropertyAccessorSignature) jvmSignature,
337 ((PropertyAccessorDescriptor) functionDescriptor).getCorrespondingProperty(), functionDescriptor.getVisibility());
338 }
339 else if (functionDescriptor instanceof SimpleFunctionDescriptor) {
340 assert !(jvmSignature instanceof JvmPropertyAccessorSignature) : "jvmSignature for function shouldn't have JvmPropertyAccessorSignature type";
341
342 Modality modality = functionDescriptor.getModality();
343 JetMethodAnnotationWriter aw = JetMethodAnnotationWriter.visitAnnotation(mv);
344 int kotlinFlags = getFlagsForVisibility(functionDescriptor.getVisibility());
345 if (isInterface(functionDescriptor.getContainingDeclaration()) && modality != Modality.ABSTRACT) {
346 kotlinFlags |= modality == Modality.FINAL
347 ? JvmStdlibNames.FLAG_FORCE_FINAL_BIT
348 : JvmStdlibNames.FLAG_FORCE_OPEN_BIT;
349 }
350 kotlinFlags |= DescriptorKindUtils.kindToFlags(functionDescriptor.getKind());
351 aw.writeFlags(kotlinFlags);
352 if (jvmSignature.getKotlinTypeParameter() != null) {
353 aw.writeTypeParameters(jvmSignature.getKotlinTypeParameter());
354 }
355 aw.writeReturnType(jvmSignature.getKotlinReturnType());
356 aw.visitEnd();
357 }
358 else if (functionDescriptor instanceof ConstructorDescriptor) {
359 AnnotationVisitor jetConstructorVisitor = mv.visitAnnotation(JvmStdlibNames.JET_CONSTRUCTOR.getDescriptor(), true);
360
361 int flagsValue = getFlagsForVisibility(functionDescriptor.getVisibility());
362 if (JvmStdlibNames.FLAGS_DEFAULT_VALUE != flagsValue) {
363 jetConstructorVisitor.visit(JvmStdlibNames.JET_FLAGS_FIELD, flagsValue);
364 }
365
366 jetConstructorVisitor.visitEnd();
367 }
368 else {
369 throw new IllegalStateException();
370 }
371
372 Iterator<ValueParameterDescriptor> valueParameters = functionDescriptor.getValueParameters().iterator();
373 List<JvmMethodParameterSignature> kotlinParameterTypes = jvmSignature.getKotlinParameterTypes();
374
375 assert kotlinParameterTypes != null;
376
377 for (int i = 0; i < kotlinParameterTypes.size(); i++) {
378 JvmMethodParameterSignature param = kotlinParameterTypes.get(i);
379 JvmMethodParameterKind kind = param.getKind();
380 String parameterName = "$" + param.getKind().name().toLowerCase();
381
382 ValueParameterDescriptor parameterDescriptor = null;
383 if (kind == JvmMethodParameterKind.VALUE) {
384 parameterDescriptor = valueParameters.next();
385 parameterName = parameterDescriptor.getName().asString();
386 } else if (kind == JvmMethodParameterKind.ENUM_NAME || kind == JvmMethodParameterKind.ENUM_ORDINAL) {
387 //we shouldn't generate annotations for invisible in runtime parameters otherwise we get bad RuntimeInvisibleParameterAnnotations error in javac
388 continue;
389 } else if (needIndexForVar(kind)) {
390 parameterName = parameterName + "$" + i;
391 }
392
393 AnnotationCodegen.forParameter(i, mv, typeMapper).genAnnotations(parameterDescriptor);
394 JetValueParameterAnnotationWriter av = JetValueParameterAnnotationWriter.visitParameterAnnotation(mv, i);
395 av.writeName(parameterName);
396 if (kind == JvmMethodParameterKind.RECEIVER) {
397 av.writeReceiver();
398 }
399 if (parameterDescriptor != null) {
400 av.writeHasDefaultValue(parameterDescriptor.declaresDefaultValue());
401 av.writeVararg(parameterDescriptor.getVarargElementType() != null);
402 }
403 av.writeType(param.getKotlinSignature());
404 av.visitEnd();
405 }
406 }
407
408 private boolean needIndexForVar(JvmMethodParameterKind kind) {
409 return kind == JvmMethodParameterKind.SHARED_VAR || kind == JvmMethodParameterKind.SUPER_CALL_PARAM;
410 }
411
412 public static void endVisit(MethodVisitor mv, @Nullable String description, @Nullable PsiElement method) {
413 try {
414 mv.visitMaxs(-1, -1);
415 }
416 catch (ProcessCanceledException e) {
417 throw e;
418 }
419 catch (Throwable t) {
420 throw new CompilationException(
421 "wrong code generated" +
422 (description != null ? " for " + description : "") +
423 t.getClass().getName() +
424 " " +
425 t.getMessage(),
426 t, method);
427 }
428 mv.visitEnd();
429 }
430
431 static void generateBridgeIfNeeded(
432 CodegenContext owner,
433 GenerationState state,
434 ClassBuilder v,
435 Method jvmSignature,
436 FunctionDescriptor functionDescriptor
437 ) {
438 if (owner.getContextKind() == OwnerKind.TRAIT_IMPL) {
439 return;
440 }
441
442 Method method =
443 state.getTypeMapper().mapSignature(functionDescriptor).getAsmMethod();
444
445 Queue<FunctionDescriptor> bfsQueue = new LinkedList<FunctionDescriptor>();
446 Set<FunctionDescriptor> visited = new HashSet<FunctionDescriptor>();
447
448 bfsQueue.offer(functionDescriptor.getOriginal());
449 visited.add(functionDescriptor.getOriginal());
450 for (FunctionDescriptor overriddenDescriptor : functionDescriptor.getOverriddenDescriptors()) {
451 FunctionDescriptor orig = overriddenDescriptor.getOriginal();
452 if (!visited.contains(orig)) {
453 bfsQueue.offer(overriddenDescriptor);
454 visited.add(overriddenDescriptor);
455 }
456 }
457
458 Set<Method> bridgesToGenerate = new HashSet<Method>();
459 while (!bfsQueue.isEmpty()) {
460 FunctionDescriptor descriptor = bfsQueue.poll();
461 if (descriptor.getKind() == CallableMemberDescriptor.Kind.DECLARATION) {
462 Method overridden =
463 state.getTypeMapper().mapSignature(descriptor.getOriginal()).getAsmMethod();
464 if (differentMethods(method, overridden)) {
465 bridgesToGenerate.add(overridden);
466 }
467 continue;
468 }
469
470 for (FunctionDescriptor overriddenDescriptor : descriptor.getOverriddenDescriptors()) {
471 FunctionDescriptor orig = overriddenDescriptor.getOriginal();
472 if (!visited.contains(orig)) {
473 bfsQueue.offer(orig);
474 visited.add(orig);
475 }
476 }
477 }
478
479 for (Method overridden : bridgesToGenerate) {
480 generateBridge(owner, state, v, jvmSignature, functionDescriptor, overridden);
481 }
482 }
483
484 static void generateConstructorWithoutParametersIfNeeded(
485 @NotNull GenerationState state,
486 @NotNull CallableMethod method,
487 @NotNull ConstructorDescriptor constructorDescriptor,
488 @NotNull ClassBuilder classBuilder
489 ) {
490 if (!isDefaultConstructorNeeded(state.getBindingContext(), constructorDescriptor)) {
491 return;
492 }
493 int flags = getVisibilityAccessFlag(constructorDescriptor);
494 MethodVisitor mv = classBuilder.newMethod(null, flags, "<init>", "()V", null, null);
495
496 if (state.getClassBuilderMode() == ClassBuilderMode.SIGNATURES) {
497 return;
498 }
499 else if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
500 genStubCode(mv);
501 }
502 else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
503 InstructionAdapter v = new InstructionAdapter(mv);
504 mv.visitCode();
505
506 JvmClassName ownerInternalName = method.getOwner();
507 Method jvmSignature = method.getSignature().getAsmMethod();
508 v.load(0, ownerInternalName.getAsmType()); // Load this on stack
509
510 int mask = 0;
511 for (ValueParameterDescriptor parameterDescriptor : constructorDescriptor.getValueParameters()) {
512 Type paramType = state.getTypeMapper().mapType(parameterDescriptor.getType());
513 pushDefaultValueOnStack(paramType, v);
514 mask |= (1 << parameterDescriptor.getIndex());
515 }
516 v.iconst(mask);
517 String desc = jvmSignature.getDescriptor().replace(")", "I)");
518 v.invokespecial(ownerInternalName.getInternalName(), "<init>", desc);
519 v.areturn(Type.VOID_TYPE);
520 endVisit(mv, "default constructor for " + ownerInternalName.getInternalName(), null);
521 }
522 }
523
524 static void generateDefaultIfNeeded(
525 @NotNull MethodContext owner,
526 @NotNull GenerationState state,
527 @NotNull ClassBuilder v,
528 @NotNull JvmMethodSignature signature,
529 @NotNull FunctionDescriptor functionDescriptor,
530 @NotNull OwnerKind kind,
531 @NotNull DefaultParameterValueLoader loadStrategy
532 ) {
533 DeclarationDescriptor contextClass = owner.getContextDescriptor().getContainingDeclaration();
534
535 if (kind != OwnerKind.TRAIT_IMPL &&
536 contextClass instanceof ClassDescriptor &&
537 ((ClassDescriptor) contextClass).getKind() == ClassKind.TRAIT) {
538 return;
539 }
540
541 if (!isDefaultNeeded(functionDescriptor)) {
542 return;
543 }
544
545 boolean isStatic = isStatic(kind);
546
547 Method jvmSignature = signature.getAsmMethod();
548
549 int flags = ACC_PUBLIC | ACC_SYNTHETIC; // TODO.
550
551 JvmClassName ownerInternalName;
552 if (contextClass instanceof NamespaceDescriptor) {
553 ownerInternalName = state.getTypeMapper().getOwner(functionDescriptor, kind, true);
554 }
555 else {
556 ownerInternalName = JvmClassName.byType(state.getTypeMapper()
557 .mapType(((ClassDescriptor) contextClass).getDefaultType(),
558 JetTypeMapperMode.IMPL));
559 }
560
561 String descriptor = jvmSignature.getDescriptor().replace(")", "I)");
562 boolean isConstructor = "<init>".equals(jvmSignature.getName());
563 if (!isStatic && !isConstructor) {
564 descriptor = descriptor.replace("(", "(" + ownerInternalName.getDescriptor());
565 }
566 MethodVisitor mv = v.newMethod(null, flags | (isConstructor ? 0 : ACC_STATIC),
567 isConstructor ? "<init>" : jvmSignature.getName() + JvmAbi.DEFAULT_PARAMS_IMPL_SUFFIX,
568 descriptor, null, null);
569
570 if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
571 genStubCode(mv);
572 }
573 else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
574 generateDefaultImpl(owner, state, signature, functionDescriptor, kind, isStatic, mv, loadStrategy);
575 }
576 }
577
578 private static void generateDefaultImpl(
579 @NotNull MethodContext methodContext,
580 @NotNull GenerationState state,
581 @NotNull JvmMethodSignature signature,
582 @NotNull FunctionDescriptor functionDescriptor,
583 @NotNull OwnerKind kind,
584 boolean aStatic,
585 @NotNull MethodVisitor mv,
586 @NotNull DefaultParameterValueLoader loadStrategy
587 ) {
588 mv.visitCode();
589
590 FrameMap frameMap = new FrameMap();
591
592 if (!aStatic) {
593 frameMap.enterTemp(OBJECT_TYPE);
594 }
595
596 Method jvmSignature = signature.getAsmMethod();
597 ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, jvmSignature.getReturnType(), methodContext, state);
598
599 Type[] argTypes = jvmSignature.getArgumentTypes();
600 List<ValueParameterDescriptor> paramDescrs = functionDescriptor.getValueParameters();
601 Iterator<ValueParameterDescriptor> iterator = paramDescrs.iterator();
602
603 int countOfExtraVarsInMethodArgs = 0;
604 List<JvmMethodParameterSignature> params = signature.getKotlinParameterTypes();
605
606 for (int i = 0; i < params.size(); i++) {
607 JvmMethodParameterSignature parameterSignature = params.get(i);
608 if (parameterSignature.getKind() != JvmMethodParameterKind.VALUE) {
609 countOfExtraVarsInMethodArgs++;
610 frameMap.enterTemp(parameterSignature.getAsmType());
611 } else {
612 frameMap.enter(iterator.next(), parameterSignature.getAsmType());
613 }
614 }
615
616 int maskIndex = frameMap.enterTemp(Type.INT_TYPE);
617
618 InstructionAdapter iv = new InstructionAdapter(mv);
619 loadExplicitArgumentsOnStack(iv, OBJECT_TYPE, aStatic, signature);
620
621 for (int index = 0; index < paramDescrs.size(); index++) {
622 ValueParameterDescriptor parameterDescriptor = paramDescrs.get(index);
623
624 Type t = argTypes[countOfExtraVarsInMethodArgs + index];
625
626 if (parameterDescriptor.declaresDefaultValue()) {
627 iv.load(maskIndex, Type.INT_TYPE);
628 iv.iconst(1 << index);
629 iv.and(Type.INT_TYPE);
630 Label loadArg = new Label();
631 iv.ifeq(loadArg);
632
633 loadStrategy.putValueOnStack(parameterDescriptor, codegen);
634
635 int ind = frameMap.getIndex(parameterDescriptor);
636 iv.store(ind, t);
637
638 iv.mark(loadArg);
639 }
640
641 iv.load(frameMap.getIndex(parameterDescriptor), t);
642 }
643
644 CallableMethod method = null;
645 if (functionDescriptor instanceof ConstructorDescriptor) {
646 method = state.getTypeMapper().mapToCallableMethod((ConstructorDescriptor) functionDescriptor);
647 } else {
648 method = state.getTypeMapper()
649 .mapToCallableMethod(functionDescriptor, false, isCallInsideSameClassAsDeclared(functionDescriptor, methodContext),
650 isCallInsideSameModuleAsDeclared(functionDescriptor, methodContext), OwnerKind.IMPLEMENTATION);
651 }
652
653 iv.visitMethodInsn(method.getInvokeOpcode(), method.getOwner().getInternalName(), method.getSignature().getAsmMethod().getName(),
654 method.getSignature().getAsmMethod().getDescriptor());
655
656 iv.areturn(jvmSignature.getReturnType());
657
658 endVisit(mv, "default method", callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor));
659 mv.visitEnd();
660 }
661
662
663 private static void loadExplicitArgumentsOnStack(
664 @NotNull InstructionAdapter iv,
665 @NotNull Type ownerType,
666 boolean isStatic,
667 @NotNull JvmMethodSignature signature
668 ) {
669 int var = 0;
670 if (!isStatic) {
671 iv.load(var, ownerType);
672 var += ownerType.getSize();
673 }
674
675 List<JvmMethodParameterSignature> params = signature.getKotlinParameterTypes();
676 for (int i = 0; i < params.size(); i++) {
677 JvmMethodParameterSignature parameterSignature = params.get(i);
678 if (parameterSignature.getKind() != JvmMethodParameterKind.VALUE) {
679 Type type = parameterSignature.getAsmType();
680 iv.load(var, type);
681 var += type.getSize();
682 }
683 }
684 }
685
686 private static boolean isDefaultNeeded(FunctionDescriptor functionDescriptor) {
687 boolean needed = false;
688 if (functionDescriptor != null) {
689 for (ValueParameterDescriptor parameterDescriptor : functionDescriptor.getValueParameters()) {
690 if (parameterDescriptor.declaresDefaultValue()) {
691 needed = true;
692 break;
693 }
694 }
695 }
696 return needed;
697 }
698
699 private static boolean isDefaultConstructorNeeded(@NotNull BindingContext context, @NotNull ConstructorDescriptor constructorDescriptor) {
700 ClassDescriptor classDescriptor = constructorDescriptor.getContainingDeclaration();
701
702 if (CodegenBinding.canHaveOuter(context, classDescriptor)) return false;
703
704 if (classDescriptor.getVisibility() == Visibilities.PRIVATE ||
705 constructorDescriptor.getVisibility() == Visibilities.PRIVATE) return false;
706
707 if (constructorDescriptor.getValueParameters().isEmpty()) return false;
708
709 for (ValueParameterDescriptor parameterDescriptor : constructorDescriptor.getValueParameters()) {
710 if (!parameterDescriptor.declaresDefaultValue()) {
711 return false;
712 }
713 }
714 return true;
715 }
716
717 private static boolean differentMethods(Method method, Method overridden) {
718 if (!method.getReturnType().equals(overridden.getReturnType())) {
719 return true;
720 }
721 Type[] methodArgumentTypes = method.getArgumentTypes();
722 Type[] overriddenArgumentTypes = overridden.getArgumentTypes();
723 if (methodArgumentTypes.length != overriddenArgumentTypes.length) {
724 return true;
725 }
726 for (int i = 0; i != methodArgumentTypes.length; ++i) {
727 if (!methodArgumentTypes[i].equals(overriddenArgumentTypes[i])) {
728 return true;
729 }
730 }
731 return false;
732 }
733
734 private static void generateBridge(
735 CodegenContext owner,
736 GenerationState state,
737 ClassBuilder v,
738 Method jvmSignature,
739 FunctionDescriptor functionDescriptor,
740 Method overridden
741 ) {
742 int flags = ACC_PUBLIC | ACC_BRIDGE | ACC_SYNTHETIC; // TODO.
743
744 MethodVisitor mv = v.newMethod(null, flags, jvmSignature.getName(), overridden.getDescriptor(), null, null);
745 if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
746 genStubCode(mv);
747 }
748 else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
749 mv.visitCode();
750
751 Type[] argTypes = overridden.getArgumentTypes();
752 Type[] originalArgTypes = jvmSignature.getArgumentTypes();
753
754 InstructionAdapter iv = new InstructionAdapter(mv);
755 iv.load(0, OBJECT_TYPE);
756 for (int i = 0, reg = 1; i < argTypes.length; i++) {
757 StackValue.local(reg, argTypes[i]).put(originalArgTypes[i], iv);
758 //noinspection AssignmentToForLoopParameter
759 reg += argTypes[i].getSize();
760 }
761
762 iv.invokevirtual(v.getThisName(), jvmSignature.getName(), jvmSignature.getDescriptor());
763
764 StackValue.onStack(jvmSignature.getReturnType()).put(overridden.getReturnType(), iv);
765
766 iv.areturn(overridden.getReturnType());
767 endVisit(mv, "bridge method", callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor));
768 }
769 }
770
771 public void genDelegate(FunctionDescriptor functionDescriptor, FunctionDescriptor overriddenDescriptor, StackValue field) {
772 genDelegate(functionDescriptor, (ClassDescriptor) overriddenDescriptor.getContainingDeclaration(), field,
773 typeMapper.mapSignature(functionDescriptor),
774 typeMapper.mapSignature(overriddenDescriptor.getOriginal())
775 );
776 }
777
778 public void genDelegate(
779 FunctionDescriptor functionDescriptor,
780 ClassDescriptor toClass,
781 StackValue field,
782 JvmMethodSignature jvmDelegateMethodSignature,
783 JvmMethodSignature jvmOverriddenMethodSignature
784 ) {
785 Method overriddenMethod = jvmOverriddenMethodSignature.getAsmMethod();
786 Method delegateMethod = jvmDelegateMethodSignature.getAsmMethod();
787
788 int flags = ACC_PUBLIC | ACC_SYNTHETIC; // TODO.
789
790 MethodVisitor mv = v.newMethod(null, flags, delegateMethod.getName(), delegateMethod.getDescriptor(), null, null);
791 if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
792 genStubCode(mv);
793 }
794 else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
795 mv.visitCode();
796
797 Type[] argTypes = delegateMethod.getArgumentTypes();
798 Type[] originalArgTypes = overriddenMethod.getArgumentTypes();
799
800 InstructionAdapter iv = new InstructionAdapter(mv);
801 iv.load(0, OBJECT_TYPE);
802 field.put(field.type, iv);
803 for (int i = 0, reg = 1; i < argTypes.length; i++) {
804 StackValue.local(reg, argTypes[i]).put(originalArgTypes[i], iv);
805 //noinspection AssignmentToForLoopParameter
806 reg += argTypes[i].getSize();
807 }
808
809 String internalName = typeMapper.mapType(toClass).getInternalName();
810 if (toClass.getKind() == ClassKind.TRAIT) {
811 iv.invokeinterface(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor());
812 }
813 else {
814 iv.invokevirtual(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor());
815 }
816
817 StackValue.onStack(overriddenMethod.getReturnType()).put(delegateMethod.getReturnType(), iv);
818
819 iv.areturn(delegateMethod.getReturnType());
820 endVisit(mv, "Delegate method " + functionDescriptor + " to " + jvmOverriddenMethodSignature,
821 descriptorToDeclaration(bindingContext, functionDescriptor.getContainingDeclaration()));
822
823 generateBridgeIfNeeded(owner, state, v, jvmDelegateMethodSignature.getAsmMethod(), functionDescriptor);
824 }
825 }
826 }