public void resolve(ClassScope upperScope) {
if (munger == null) ignoreFurtherInvestigation = true;
if (ignoreFurtherInvestigation) return;
EclipseFactory world = EclipseFactory.fromScopeLookupEnvironment(upperScope);
ResolvedMember sig = munger.getSignature();
UnresolvedType aspectType = world.fromBinding(upperScope.referenceContext.binding);
if (sig.getReturnType() == ResolvedType.VOID ||
(sig.getReturnType().isArray() && (sig.getReturnType().getComponentType() == ResolvedType.VOID)))
{
upperScope.problemReporter().signalError(sourceStart, sourceEnd,
"field type can not be void");
}
//
// System.err.println("sig: " + sig);
// System.err.println("field: " + world.makeFieldBinding(
// AjcMemberMaker.interFieldClassField(sig, aspectType)));
if (initialization != null && initialization instanceof ArrayInitializer) {
//System.err.println("got initializer: " + initialization);
ArrayAllocationExpression aae = new ArrayAllocationExpression();
aae.initializer = (ArrayInitializer)initialization;
ArrayBinding arrayType = (ArrayBinding)world.makeTypeBinding(sig.getReturnType());
aae.type = AstUtil.makeTypeReference(arrayType.leafComponentType());
aae.sourceStart = initialization.sourceStart;
aae.sourceEnd = initialization.sourceEnd;
aae.dimensions = new Expression[arrayType.dimensions];
initialization = aae;
} /*else if (initialization!=null) {
MethodScope initializationScope = this.scope;
TypeBinding fieldType = realFieldType;
TypeBinding initializationType;
this.initialization.setExpectedType(fieldType); // needed in case of generic method invocation
if (this.initialization instanceof ArrayInitializer) {
if ((initializationType = this.initialization.resolveTypeExpecting(initializationScope, fieldType)) != null) {
((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationType;
this.initialization.computeConversion(initializationScope, fieldType, initializationType);
}
}
// System.err.println("i=>"+initialization);
// System.err.println("sasuages=>"+initialization.resolvedType);
// //initializationType = initialization.resolveType(initializationScope);
// System.err.println("scope=>"+initializationScope);
else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) {
if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError()
initializationScope.compilationUnitScope().recordTypeConversion(fieldType, initializationType);
if (this.initialization.isConstantValueOfTypeAssignableToType(initializationType, fieldType)
|| (fieldType.isBaseType() && BaseTypeBinding.isWidening(fieldType.id, initializationType.id))
|| initializationType.isCompatibleWith(fieldType)) {
initialization.computeConversion(initializationScope, fieldType, initializationType);
if (initializationType.needsUncheckedConversion(fieldType)) {
initializationScope.problemReporter().unsafeTypeConversion(this.initialization, initializationType, fieldType);
}
} else if (initializationScope.isBoxingCompatibleWith(initializationType, fieldType)
|| (initializationType.isBaseType() // narrowing then boxing ?
&& initializationScope.compilerOptions().sourceLevel >= JDK1_5 // autoboxing
&& !fieldType.isBaseType()
&& initialization.isConstantValueOfTypeAssignableToType(initializationType, initializationScope.environment().computeBoxingType(fieldType)))) {
this.initialization.computeConversion(initializationScope, fieldType, initializationType);
} else {
initializationScope.problemReporter().typeMismatchError(initializationType, fieldType, this);
}
// if (this.binding.isFinal()){ // cast from constant actual type to variable type
// this.binding.setConstant(this.initialization.constant.castTo((this.binding.returnType.id << 4) + this.initialization.constant.typeID()));
// }
// } else {
// this.binding.setConstant(NotAConstant);
}
//
}
*/
//////////////////////
if (initialization == null) {
this.statements = new Statement[] {
new ReturnStatement(null, 0, 0),
};
} else if (!onTypeBinding.isInterface()) {
MethodBinding writeMethod = world.makeMethodBinding(
AjcMemberMaker.interFieldSetDispatcher(sig,aspectType),munger.getTypeVariableAliases());
// For the body of an intertype field initalizer, generate a call to the inter field set dispatcher
// method as that casts the shadow of a field set join point.
if (Modifier.isStatic(declaredModifiers)) {
this.statements = new Statement[] {
new KnownMessageSend(writeMethod,
AstUtil.makeNameReference(writeMethod.declaringClass),
new Expression[] {initialization}),
};
} else {
this.statements = new Statement[] {
new KnownMessageSend(writeMethod,
AstUtil.makeNameReference(writeMethod.declaringClass),
new Expression[] {AstUtil.makeLocalVariableReference(arguments[0].binding),initialization}),
};
}
} else {
//XXX something is broken about this logic. Can we write to static interface fields?
MethodBinding writeMethod = world.makeMethodBinding(
AjcMemberMaker.interFieldInterfaceSetter(sig, sig.getDeclaringType().resolve(world.getWorld()), aspectType),munger.getTypeVariableAliases());
if (Modifier.isStatic(declaredModifiers)) {
this.statements = new Statement[] {
new KnownMessageSend(writeMethod,
AstUtil.makeNameReference(writeMethod.declaringClass),
new Expression[] {initialization}),