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 }), };
} else {