@NotNull
protected ExpressionCodegen createOrGetClInitCodegen() {
DeclarationDescriptor descriptor = context.getContextDescriptor();
assert state.getClassBuilderMode() == ClassBuilderMode.FULL
: "<clinit> should not be generated for light classes. Descriptor: " + descriptor;
if (clInit == null) {
MethodVisitor mv = v.newMethod(null, ACC_STATIC, "<clinit>", "()V", null, null);
mv.visitCode();
SimpleFunctionDescriptorImpl clInit =
SimpleFunctionDescriptorImpl.create(
descriptor, Annotations.EMPTY, Name.special("<clinit>"), SYNTHESIZED);
clInit.initialize(
null,
null,
Collections.<TypeParameterDescriptor>emptyList(),
Collections.<ValueParameterDescriptor>emptyList(),
null,
null,
Visibilities.PRIVATE);
this.clInit =
new ExpressionCodegen(
mv, new FrameMap(), Type.VOID_TYPE, context.intoFunction(clInit), state, this);
}
return clInit;
}
@NotNull
public static SimpleFunctionDescriptor createSamAdapterFunction(
@NotNull SimpleFunctionDescriptor original) {
SimpleFunctionDescriptorImpl result =
new SimpleFunctionDescriptorImpl(
original.getContainingDeclaration(),
original.getAnnotations(),
original.getName(),
CallableMemberDescriptor.Kind.SYNTHESIZED);
TypeParameters typeParameters =
recreateAndInitializeTypeParameters(original.getTypeParameters(), result);
JetType returnTypeUnsubstituted = original.getReturnType();
assert returnTypeUnsubstituted != null : original;
JetType returnType =
typeParameters.substitutor.substitute(returnTypeUnsubstituted, Variance.OUT_VARIANCE);
assert returnType != null
: "couldn't substitute type: "
+ returnType
+ ", substitutor = "
+ typeParameters.substitutor;
List<ValueParameterDescriptor> valueParameters = Lists.newArrayList();
for (ValueParameterDescriptor originalParam : original.getValueParameters()) {
JetType originalType = originalParam.getType();
JetType newTypeUnsubstituted =
isSamType(originalType) ? getFunctionTypeForSamType(originalType) : originalType;
JetType newType =
typeParameters.substitutor.substitute(newTypeUnsubstituted, Variance.IN_VARIANCE);
assert newType != null
: "couldn't substitute type: "
+ newTypeUnsubstituted
+ ", substitutor = "
+ typeParameters.substitutor;
ValueParameterDescriptor newParam =
new ValueParameterDescriptorImpl(
result,
originalParam.getIndex(),
originalParam.getAnnotations(),
originalParam.getName(),
newType,
false,
null);
valueParameters.add(newParam);
}
result.initialize(
null,
original.getExpectedThisObject(),
typeParameters.descriptors,
valueParameters,
returnType,
original.getModality(),
original.getVisibility(),
false);
return result;
}
@NotNull
public static SimpleFunctionDescriptor createSamConstructorFunction(
@NotNull ClassOrNamespaceDescriptor owner, @NotNull ClassDescriptor samInterface) {
assert isSamInterface(samInterface) : samInterface;
SimpleFunctionDescriptorImpl result =
new SimpleFunctionDescriptorImpl(
owner,
samInterface.getAnnotations(),
samInterface.getName(),
CallableMemberDescriptor.Kind.SYNTHESIZED);
TypeParameters typeParameters =
recreateAndInitializeTypeParameters(
samInterface.getTypeConstructor().getParameters(), result);
JetType parameterTypeUnsubstituted = getFunctionTypeForSamType(samInterface.getDefaultType());
JetType parameterType =
typeParameters.substitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE);
assert parameterType != null
: "couldn't substitute type: "
+ parameterType
+ ", substitutor = "
+ typeParameters.substitutor;
ValueParameterDescriptor parameter =
new ValueParameterDescriptorImpl(
result,
0,
Collections.<AnnotationDescriptor>emptyList(),
Name.identifier("function"),
parameterType,
false,
null);
JetType returnType =
typeParameters.substitutor.substitute(samInterface.getDefaultType(), Variance.OUT_VARIANCE);
assert returnType != null
: "couldn't substitute type: "
+ returnType
+ ", substitutor = "
+ typeParameters.substitutor;
result.initialize(
null,
null,
typeParameters.descriptors,
Arrays.asList(parameter),
returnType,
Modality.FINAL,
samInterface.getVisibility(),
false);
return result;
}
@Nullable
private static JetType computeUnsafeReturnType(
@NotNull JetFunctionLiteralExpression expression,
@NotNull ExpressionTypingContext context,
@NotNull SimpleFunctionDescriptorImpl functionDescriptor,
@Nullable JetType expectedReturnType) {
JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
JetBlockExpression bodyExpression = functionLiteral.getBodyExpression();
assert bodyExpression != null;
JetScope functionInnerScope =
FunctionDescriptorUtil.getFunctionInnerScope(
context.scope, functionDescriptor, context.trace);
JetTypeReference returnTypeRef = functionLiteral.getReturnTypeRef();
JetType declaredReturnType = null;
if (returnTypeRef != null) {
declaredReturnType =
context
.expressionTypingServices
.getTypeResolver()
.resolveType(context.scope, returnTypeRef, context.trace, true);
// This is needed for ControlStructureTypingVisitor#visitReturnExpression() to properly
// type-check returned expressions
functionDescriptor.setReturnType(declaredReturnType);
if (expectedReturnType != null) {
if (!JetTypeChecker.INSTANCE.isSubtypeOf(declaredReturnType, expectedReturnType)) {
context.trace.report(EXPECTED_RETURN_TYPE_MISMATCH.on(returnTypeRef, expectedReturnType));
}
}
}
// Type-check the body
ExpressionTypingContext newContext =
context
.replaceScope(functionInnerScope)
.replaceExpectedType(
declaredReturnType != null
? declaredReturnType
: (expectedReturnType != null ? expectedReturnType : NO_EXPECTED_TYPE));
JetType typeOfBodyExpression =
context
.expressionTypingServices
.getBlockReturnedType(bodyExpression, COERCION_TO_UNIT, newContext)
.getType();
List<JetType> returnedExpressionTypes =
Lists.newArrayList(
getTypesOfLocallyReturnedExpressions(
functionLiteral, context.trace, collectReturns(bodyExpression)));
ContainerUtil.addIfNotNull(returnedExpressionTypes, typeOfBodyExpression);
if (declaredReturnType != null) return declaredReturnType;
if (returnedExpressionTypes.isEmpty()) return null;
return CommonSupertypes.commonSupertype(returnedExpressionTypes);
}
