private void generateDefaultSetter(JetProperty p) {
final PropertyDescriptor propertyDescriptor =
(PropertyDescriptor) state.getBindingContext().get(BindingContext.VARIABLE, p);
assert propertyDescriptor != null;
int modifiers = JetTypeMapper.getAccessModifiers(propertyDescriptor, 0);
PropertySetterDescriptor setter = propertyDescriptor.getSetter();
int flags = setter == null ? modifiers : JetTypeMapper.getAccessModifiers(setter, modifiers);
generateDefaultSetter(propertyDescriptor, flags, p);
}
public GeneratedAnonymousClassDescriptor generateObjectLiteral(
JetObjectLiteralExpression literal, ObjectOrClosureCodegen closure) {
JetObjectDeclaration objectDeclaration = literal.getObjectDeclaration();
Pair<String, ClassBuilder> nameAndVisitor = forAnonymousSubclass(objectDeclaration);
closure.cv = nameAndVisitor.getSecond();
closure.name = nameAndVisitor.getFirst();
final CodegenContext objectContext =
closure.context.intoAnonymousClass(
closure,
getBindingContext().get(BindingContext.CLASS, objectDeclaration),
OwnerKind.IMPLEMENTATION,
typeMapper);
new ImplementationBodyCodegen(
objectDeclaration, objectContext, nameAndVisitor.getSecond(), this)
.generate();
ConstructorDescriptor constructorDescriptor =
closure.state.getBindingContext().get(BindingContext.CONSTRUCTOR, objectDeclaration);
CallableMethod callableMethod =
closure
.state
.getTypeMapper()
.mapToCallableMethod(
constructorDescriptor,
OwnerKind.IMPLEMENTATION,
typeMapper.hasThis0(constructorDescriptor.getContainingDeclaration()));
return new GeneratedAnonymousClassDescriptor(
nameAndVisitor.first,
callableMethod.getSignature().getAsmMethod(),
objectContext.outerWasUsed,
null);
}
private void generateDefaultGetter(JetProperty p) {
final PropertyDescriptor propertyDescriptor =
(PropertyDescriptor) state.getBindingContext().get(BindingContext.VARIABLE, p);
int flags =
JetTypeMapper.getAccessModifiers(propertyDescriptor, 0)
| (propertyDescriptor.getModality() == Modality.ABSTRACT ? Opcodes.ACC_ABSTRACT : 0);
generateDefaultGetter(propertyDescriptor, flags, p);
}
private void generateBackingField(JetProperty p, PropertyDescriptor propertyDescriptor) {
if (state.getBindingContext().get(BindingContext.BACKING_FIELD_REQUIRED, propertyDescriptor)) {
DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration();
if (CodegenUtil.isInterface(containingDeclaration)) return;
Object value = null;
final JetExpression initializer = p.getInitializer();
if (initializer != null) {
if (initializer instanceof JetConstantExpression) {
CompileTimeConstant<?> compileTimeValue =
state.getBindingContext().get(BindingContext.COMPILE_TIME_VALUE, initializer);
value = compileTimeValue != null ? compileTimeValue.getValue() : null;
}
}
int modifiers;
if (kind == OwnerKind.NAMESPACE) {
int access = JetTypeMapper.getAccessModifiers(propertyDescriptor, 0);
modifiers = access | Opcodes.ACC_STATIC;
} else {
modifiers = JetTypeMapper.getAccessModifiers(propertyDescriptor, 0);
}
if (!propertyDescriptor.isVar()) {
modifiers |= Opcodes.ACC_FINAL;
}
if (state.getInjector().getJetStandardLibrary().isVolatile(propertyDescriptor)) {
modifiers |= Opcodes.ACC_VOLATILE;
}
Type type =
state
.getInjector()
.getJetTypeMapper()
.mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
FieldVisitor fieldVisitor =
v.newField(p, modifiers, p.getName(), type.getDescriptor(), null, value);
AnnotationCodegen.forField(fieldVisitor, state.getInjector().getJetTypeMapper())
.genAnnotations(propertyDescriptor);
}
}
public ClassBuilder forClassImplementation(ClassDescriptor aClass) {
return factory.newVisitor(
typeMapper.mapType(aClass.getDefaultType(), OwnerKind.IMPLEMENTATION).getInternalName()
+ ".class");
}
public Pair<String, ClassBuilder> forAnonymousSubclass(JetExpression expression) {
String className = typeMapper.getClosureAnnotator().classNameForAnonymousClass(expression);
return Pair.create(className, factory.forAnonymousSubclass(className));
}
