### Eclipse Workspace Patch 1.0 #P org.eclipse.jdt.core.tests.compiler Index: src/org/eclipse/jdt/core/tests/compiler/regression/InnerEmulationTest.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/InnerEmulationTest.java,v retrieving revision 1.45 diff -u -r1.45 InnerEmulationTest.java --- src/org/eclipse/jdt/core/tests/compiler/regression/InnerEmulationTest.java 30 Sep 2008 17:30:10 -0000 1.45 +++ src/org/eclipse/jdt/core/tests/compiler/regression/InnerEmulationTest.java 1 Oct 2008 16:47:35 -0000 @@ -6862,7 +6862,80 @@ " 0 invokestatic package2.C.outerMethod() : void"; checkDisassembledClassFile(OUTPUT_DIR + File.separator + "package2" + File.separator + "C.class", "C", expectedOutput); } - +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=249107 - variation +public void test166() throws Exception { + this.runConformTest(new String[] { + "X.java",//======================= + "class XSuper {\n" + + " protected String field = \"[XSuper#field]\";//$NON-NLS-1$\n" + + "}\n" + + "public class X extends XSuper {\n" + + " protected String field = \"[X#field]\";//$NON-NLS-1$\n" + + " public static void main(String[] args) {\n" + + " new X().foo();\n" + + " }\n" + + " void foo() {\n" + + " new Object() {\n" + + " void bar() {\n" + + " System.out.print(\"X.this.field=\" + X.this.field);\n" + + " System.out.print(\"X.super.field=\" + X.super.field);\n" + + " }\n" + + " }.bar();\n" + + " }\n" + + "}\n", + }, + "X.this.field=[X#field]X.super.field=[XSuper#field]"); +} +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=249107 - variation +public void test167() throws Exception { + this.runConformTest(new String[] { + "X.java",//======================= + "class XSuper {\n" + + " protected String method() { return \"[XSuper#method()]\"; }//$NON-NLS-1$\n" + + "}\n" + + "public class X extends XSuper {\n" + + " protected String method() { return \"[X#method()]\"; }//$NON-NLS-1$\n" + + " public static void main(String[] args) {\n" + + " new X().foo();\n" + + " }\n" + + " void foo() {\n" + + " new Object() {\n" + + " void bar() {\n" + + " System.out.print(\"X.this.method()=\" + X.this.method());\n" + + " System.out.print(\"X.super.method()=\" + X.super.method());\n" + + " }\n" + + " }.bar();\n" + + " }\n" + + "}\n", + }, + "X.this.method()=[X#method()]X.super.method()=[XSuper#method()]"); +} +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=249107 - variation +public void test168() throws Exception { + this.runConformTest(new String[] { + "X.java",//======================= + "class XSuper {\n" + + " protected String field;\n" + + "}\n" + + "public class X extends XSuper {\n" + + " protected String field;\n" + + " public static void main(String[] args) {\n" + + " new X().foo();\n" + + " }\n" + + " void foo() {\n" + + " new Object() {\n" + + " void bar() {\n" + + " X.this.field = \"[X#field]\";\n" + + " X.super.field = \"[XSuper#field]\";\n" + + " System.out.print(\"X.this.field=\" + X.this.field);\n" + + " System.out.print(\"X.super.field=\" + X.super.field);\n" + + " }\n" + + " }.bar();\n" + + " }\n" + + "}\n", + }, + "X.this.field=[X#field]X.super.field=[XSuper#field]"); +} public static Class testClass() { return InnerEmulationTest.class; } #P org.eclipse.jdt.core Index: compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java,v retrieving revision 1.162 diff -u -r1.162 SourceTypeBinding.java --- compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java 25 Sep 2008 23:10:30 -0000 1.162 +++ compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java 1 Oct 2008 16:47:40 -0000 @@ -354,7 +354,7 @@ /* Add a new synthetic access method for read/write access to . Answer the new method or the existing method if one already existed. */ -public SyntheticMethodBinding addSyntheticMethod(FieldBinding targetField, boolean isReadAccess) { +public SyntheticMethodBinding addSyntheticMethod(FieldBinding targetField, boolean isReadAccess, boolean isSuperAccess) { if (this.synthetics == null) this.synthetics = new HashMap[MAX_SYNTHETICS]; if (this.synthetics[SourceTypeBinding.METHOD_EMUL] == null) @@ -363,12 +363,12 @@ SyntheticMethodBinding accessMethod = null; SyntheticMethodBinding[] accessors = (SyntheticMethodBinding[]) this.synthetics[SourceTypeBinding.METHOD_EMUL].get(targetField); if (accessors == null) { - accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, this); + accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, isSuperAccess, this); this.synthetics[SourceTypeBinding.METHOD_EMUL].put(targetField, accessors = new SyntheticMethodBinding[2]); accessors[isReadAccess ? 0 : 1] = accessMethod; } else { if ((accessMethod = accessors[isReadAccess ? 0 : 1]) == null) { - accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, this); + accessMethod = new SyntheticMethodBinding(targetField, isReadAccess, isSuperAccess, this); accessors[isReadAccess ? 0 : 1] = accessMethod; } } Index: compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java,v retrieving revision 1.19 diff -u -r1.19 SyntheticMethodBinding.java --- compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java 27 Jun 2008 16:04:02 -0000 1.19 +++ compiler/org/eclipse/jdt/internal/compiler/lookup/SyntheticMethodBinding.java 1 Oct 2008 16:47:40 -0000 @@ -26,18 +26,20 @@ public final static int FieldReadAccess = 1; // field read public final static int FieldWriteAccess = 2; // field write - public final static int MethodAccess = 3; // normal method - public final static int ConstructorAccess = 4; // constructor - public final static int SuperMethodAccess = 5; // super method - public final static int BridgeMethod = 6; // bridge method - public final static int EnumValues = 7; // enum #values() - public final static int EnumValueOf = 8; // enum #valueOf(String) - public final static int SwitchTable = 9; // switch table method + public final static int SuperFieldReadAccess = 3; // super field read + public final static int SuperFieldWriteAccess = 4; // super field write + public final static int MethodAccess = 5; // normal method + public final static int ConstructorAccess = 6; // constructor + public final static int SuperMethodAccess = 7; // super method + public final static int BridgeMethod = 8; // bridge method + public final static int EnumValues = 9; // enum #values() + public final static int EnumValueOf = 10; // enum #valueOf(String) + public final static int SwitchTable = 11; // switch table method public int sourceStart = 0; // start position of the matching declaration public int index; // used for sorting access methods in the class file - public SyntheticMethodBinding(FieldBinding targetField, boolean isReadAccess, ReferenceBinding declaringClass) { + public SyntheticMethodBinding(FieldBinding targetField, boolean isReadAccess, boolean isSuperAccess, ReferenceBinding declaringClass) { this.modifiers = ClassFileConstants.AccDefault | ClassFileConstants.AccStatic | ClassFileConstants.AccSynthetic; this.tagBits |= (TagBits.AnnotationResolved | TagBits.DeprecatedAnnotationResolved); @@ -55,7 +57,7 @@ this.parameters[0] = declaringSourceType; } this.targetReadField = targetField; - this.purpose = SyntheticMethodBinding.FieldReadAccess; + this.purpose = isSuperAccess ? SyntheticMethodBinding.SuperFieldReadAccess : SyntheticMethodBinding.FieldReadAccess; } else { this.returnType = TypeBinding.VOID; if (targetField.isStatic()) { @@ -67,7 +69,7 @@ this.parameters[1] = targetField.type; } this.targetWriteField = targetField; - this.purpose = SyntheticMethodBinding.FieldWriteAccess; + this.purpose = isSuperAccess ? SyntheticMethodBinding.SuperFieldWriteAccess : SyntheticMethodBinding.FieldWriteAccess; } this.thrownExceptions = Binding.NO_EXCEPTIONS; this.declaringClass = declaringSourceType; @@ -206,12 +208,12 @@ this.sourceStart = declaringSourceType.scope.referenceContext.sourceStart; // use the target declaring class name position instead } - public SyntheticMethodBinding(MethodBinding targetMethod, boolean isSuperAccess, ReferenceBinding receiverType) { + public SyntheticMethodBinding(MethodBinding targetMethod, boolean isSuperAccess, ReferenceBinding declaringClass) { if (targetMethod.isConstructor()) { initializeConstructorAccessor(targetMethod); } else { - initializeMethodAccessor(targetMethod, isSuperAccess, receiverType); + initializeMethodAccessor(targetMethod, isSuperAccess, declaringClass); } } Index: compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java,v retrieving revision 1.114 diff -u -r1.114 BlockScope.java --- compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java 27 Jun 2008 16:04:02 -0000 1.114 +++ compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java 1 Oct 2008 16:47:40 -0000 @@ -789,7 +789,7 @@ System.arraycopy(path, 0, (path = new Object[count + 1]), 0, count); } // private access emulation is necessary since synthetic field is private - path[count++] = ((SourceTypeBinding) syntheticField.declaringClass).addSyntheticMethod(syntheticField, true); + path[count++] = ((SourceTypeBinding) syntheticField.declaringClass).addSyntheticMethod(syntheticField, true/*read*/, false /*not super access*/); currentType = currentEnclosingType; } if (currentType == targetEnclosingType Index: compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java,v retrieving revision 1.170 diff -u -r1.170 CodeStream.java --- compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java 30 Sep 2008 17:30:08 -0000 1.170 +++ compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java 1 Oct 2008 16:47:39 -0000 @@ -2448,11 +2448,15 @@ public void generateSyntheticBodyForFieldReadAccess(SyntheticMethodBinding accessMethod) { initializeMaxLocals(accessMethod); FieldBinding fieldBinding = accessMethod.targetReadField; + // target method declaring class may not be accessible (247953); + TypeBinding declaringClass = accessMethod.purpose == SyntheticMethodBinding.SuperFieldReadAccess + ? accessMethod.declaringClass.superclass() + : accessMethod.declaringClass; if (fieldBinding.isStatic()) { - fieldAccess(Opcodes.OPC_getstatic, fieldBinding, accessMethod.declaringClass); // target method declaring class may not be accessible (247953); + fieldAccess(Opcodes.OPC_getstatic, fieldBinding, declaringClass); } else { aload_0(); - fieldAccess(Opcodes.OPC_getfield, fieldBinding, accessMethod.declaringClass); // target method declaring class may not be accessible (247953); + fieldAccess(Opcodes.OPC_getfield, fieldBinding, declaringClass); } switch (fieldBinding.type.id) { // case T_void : @@ -2482,13 +2486,17 @@ public void generateSyntheticBodyForFieldWriteAccess(SyntheticMethodBinding accessMethod) { initializeMaxLocals(accessMethod); FieldBinding fieldBinding = accessMethod.targetWriteField; + // target method declaring class may not be accessible (247953); + TypeBinding declaringClass = accessMethod.purpose == SyntheticMethodBinding.SuperFieldWriteAccess + ? accessMethod.declaringClass.superclass() + : accessMethod.declaringClass; if (fieldBinding.isStatic()) { load(fieldBinding.type, 0); - fieldAccess(Opcodes.OPC_putstatic, fieldBinding, accessMethod.declaringClass); // target method declaring class may not be accessible (247953); + fieldAccess(Opcodes.OPC_putstatic, fieldBinding, declaringClass); } else { aload_0(); load(fieldBinding.type, 1); - fieldAccess(Opcodes.OPC_putfield, fieldBinding, accessMethod.declaringClass); // target method declaring class may not be accessible (247953); + fieldAccess(Opcodes.OPC_putfield, fieldBinding, declaringClass); } return_(); } Index: compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java,v retrieving revision 1.111 diff -u -r1.111 SingleNameReference.java --- compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java 25 Sep 2008 23:10:29 -0000 1.111 +++ compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java 1 Oct 2008 16:47:38 -0000 @@ -745,7 +745,7 @@ this.syntheticAccessors = new MethodBinding[2]; this.syntheticAccessors[isReadAccess ? SingleNameReference.READ : SingleNameReference.WRITE] = ((SourceTypeBinding)currentScope.enclosingSourceType(). - enclosingTypeAt((this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT)).addSyntheticMethod(codegenField, isReadAccess); + enclosingTypeAt((this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT)).addSyntheticMethod(codegenField, isReadAccess, false /*not super access*/); currentScope.problemReporter().needToEmulateFieldAccess(codegenField, this, isReadAccess); return; } Index: compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java,v retrieving revision 1.122 diff -u -r1.122 FieldReference.java --- compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java 30 Sep 2008 15:31:26 -0000 1.122 +++ compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java 1 Oct 2008 16:47:38 -0000 @@ -410,35 +410,31 @@ */ public void manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo, boolean isReadAccess) { if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0) return; - + // if field from parameterized type got found, use the original field at codegen time FieldBinding codegenBinding = this.binding.original(); - if (this.binding.isPrivate()) { if ((currentScope.enclosingSourceType() != codegenBinding.declaringClass) && this.binding.constant() == Constant.NotAConstant) { if (this.syntheticAccessors == null) this.syntheticAccessors = new MethodBinding[2]; this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = - ((SourceTypeBinding) codegenBinding.declaringClass).addSyntheticMethod(codegenBinding, isReadAccess); + ((SourceTypeBinding) codegenBinding.declaringClass).addSyntheticMethod(codegenBinding, isReadAccess, isSuperAccess()); currentScope.problemReporter().needToEmulateFieldAccess(codegenBinding, this, isReadAccess); return; } - } else if (this.receiver instanceof QualifiedSuperReference) { // qualified super - // qualified super need emulation always SourceTypeBinding destinationType = (SourceTypeBinding) (((QualifiedSuperReference) this.receiver) .currentCompatibleType); if (this.syntheticAccessors == null) this.syntheticAccessors = new MethodBinding[2]; - this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = destinationType.addSyntheticMethod(codegenBinding, isReadAccess); + this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = destinationType.addSyntheticMethod(codegenBinding, isReadAccess, isSuperAccess()); currentScope.problemReporter().needToEmulateFieldAccess(codegenBinding, this, isReadAccess); return; } else if (this.binding.isProtected()) { - SourceTypeBinding enclosingSourceType; if (((this.bits & ASTNode.DepthMASK) != 0) && this.binding.declaringClass.getPackage() @@ -449,7 +445,7 @@ (this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT); if (this.syntheticAccessors == null) this.syntheticAccessors = new MethodBinding[2]; - this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = currentCompatibleType.addSyntheticMethod(codegenBinding, isReadAccess); + this.syntheticAccessors[isReadAccess ? FieldReference.READ : FieldReference.WRITE] = currentCompatibleType.addSyntheticMethod(codegenBinding, isReadAccess, isSuperAccess()); currentScope.problemReporter().needToEmulateFieldAccess(codegenBinding, this, isReadAccess); return; } Index: compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedSuperReference.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedSuperReference.java,v retrieving revision 1.30 diff -u -r1.30 QualifiedSuperReference.java --- compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedSuperReference.java 27 Jun 2008 16:03:56 -0000 1.30 +++ compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedSuperReference.java 1 Oct 2008 16:47:38 -0000 @@ -15,58 +15,54 @@ public class QualifiedSuperReference extends QualifiedThisReference { - public QualifiedSuperReference(TypeReference name, int pos, int sourceEnd) { - super(name, pos, sourceEnd); - } - - public boolean isSuper() { - - return true; - } +public QualifiedSuperReference(TypeReference name, int pos, int sourceEnd) { + super(name, pos, sourceEnd); +} - public boolean isThis() { +public boolean isSuper() { + return true; +} - return false; - } +public boolean isThis() { + return false; +} - public StringBuffer printExpression(int indent, StringBuffer output) { +public StringBuffer printExpression(int indent, StringBuffer output) { + return this.qualification.print(0, output).append(".super"); //$NON-NLS-1$ +} - return this.qualification.print(0, output).append(".super"); //$NON-NLS-1$ +public TypeBinding resolveType(BlockScope scope) { + if ((this.bits & ParenthesizedMASK) != 0) { + scope.problemReporter().invalidParenthesizedExpression(this); + return null; + } + super.resolveType(scope); + if (this.currentCompatibleType == null) + return null; // error case + + if (this.currentCompatibleType.id == T_JavaLangObject) { + scope.problemReporter().cannotUseSuperInJavaLangObject(this); + return null; } + return this.resolvedType = this.currentCompatibleType.superclass(); +} - public TypeBinding resolveType(BlockScope scope) { +public void traverse( + ASTVisitor visitor, + BlockScope blockScope) { - if ((this.bits & ParenthesizedMASK) != 0) { - scope.problemReporter().invalidParenthesizedExpression(this); - return null; - } - super.resolveType(scope); - if (this.currentCompatibleType == null) - return null; // error case - - if (this.currentCompatibleType.id == T_JavaLangObject) { - scope.problemReporter().cannotUseSuperInJavaLangObject(this); - return null; - } - return this.resolvedType = this.currentCompatibleType.superclass(); + if (visitor.visit(this, blockScope)) { + this.qualification.traverse(visitor, blockScope); } - - public void traverse( + visitor.endVisit(this, blockScope); +} +public void traverse( ASTVisitor visitor, - BlockScope blockScope) { + ClassScope blockScope) { - if (visitor.visit(this, blockScope)) { - this.qualification.traverse(visitor, blockScope); - } - visitor.endVisit(this, blockScope); - } - public void traverse( - ASTVisitor visitor, - ClassScope blockScope) { - - if (visitor.visit(this, blockScope)) { - this.qualification.traverse(visitor, blockScope); - } - visitor.endVisit(this, blockScope); + if (visitor.visit(this, blockScope)) { + this.qualification.traverse(visitor, blockScope); } + visitor.endVisit(this, blockScope); +} } Index: compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java,v retrieving revision 1.134 diff -u -r1.134 QualifiedNameReference.java --- compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java 30 Sep 2008 15:31:25 -0000 1.134 +++ compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java 1 Oct 2008 16:47:38 -0000 @@ -815,7 +815,7 @@ FieldBinding codegenField = getCodegenBinding(index < 0 ? (this.otherBindings == null ? 0 : this.otherBindings.length) : index); ReferenceBinding declaringClass = codegenField.declaringClass; if (declaringClass != currentScope.enclosingSourceType()) { - setSyntheticAccessor(fieldBinding, index, ((SourceTypeBinding) declaringClass).addSyntheticMethod(codegenField, index >= 0 /*read-access?*/)); + setSyntheticAccessor(fieldBinding, index, ((SourceTypeBinding) declaringClass).addSyntheticMethod(codegenField, index >= 0 /*read-access?*/, false /*not super access*/)); currentScope.problemReporter().needToEmulateFieldAccess(codegenField, this, index >= 0 /*read-access?*/); return; } @@ -828,7 +828,7 @@ if (depth > 0 && (fieldBinding.declaringClass.getPackage() != currentScope.enclosingSourceType().getPackage())) { FieldBinding codegenField = getCodegenBinding(index < 0 ? (this.otherBindings == null ? 0 : this.otherBindings.length) : index); setSyntheticAccessor(fieldBinding, index, - ((SourceTypeBinding) currentScope.enclosingSourceType().enclosingTypeAt(depth)).addSyntheticMethod(codegenField, index >= 0 /*read-access?*/)); + ((SourceTypeBinding) currentScope.enclosingSourceType().enclosingTypeAt(depth)).addSyntheticMethod(codegenField, index >= 0 /*read-access?*/, false /*not super access*/)); currentScope.problemReporter().needToEmulateFieldAccess(codegenField, this, index >= 0 /*read-access?*/); return; } Index: compiler/org/eclipse/jdt/internal/compiler/ClassFile.java =================================================================== RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ClassFile.java,v retrieving revision 1.180 diff -u -r1.180 ClassFile.java --- compiler/org/eclipse/jdt/internal/compiler/ClassFile.java 25 Sep 2008 23:10:30 -0000 1.180 +++ compiler/org/eclipse/jdt/internal/compiler/ClassFile.java 1 Oct 2008 16:47:38 -0000 @@ -1046,11 +1046,13 @@ SyntheticMethodBinding syntheticMethod = syntheticMethods[i]; switch (syntheticMethod.purpose) { case SyntheticMethodBinding.FieldReadAccess : + case SyntheticMethodBinding.SuperFieldReadAccess : // generate a method info to emulate an reading access to // a non-accessible field addSyntheticFieldReadAccessMethod(syntheticMethod); break; case SyntheticMethodBinding.FieldWriteAccess : + case SyntheticMethodBinding.SuperFieldWriteAccess : // generate a method info to emulate an writing access to // a non-accessible field addSyntheticFieldWriteAccessMethod(syntheticMethod);