1) Moved net.sourceforge.phpeclipse.ui\src\net\sourceforge\phpdt back to net.sourcefo...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / SingleNameReference.java
index e681c4c..7271ede 100644 (file)
@@ -28,608 +28,751 @@ import net.sourceforge.phpdt.internal.compiler.lookup.VariableBinding;
 public class SingleNameReference extends NameReference implements OperatorIds {
        public char[] token;
 
-       public MethodBinding[] syntheticAccessors; // [0]=read accessor [1]=write accessor
+       public MethodBinding[] syntheticAccessors; // [0]=read accessor [1]=write
+                                                                                               // accessor
+
        public static final int READ = 0;
+
        public static final int WRITE = 1;
-       
-public SingleNameReference(char[] source, long pos) {
-       super();
-       token = source;
-       sourceStart = (int) (pos >>> 32);
-       sourceEnd = (int) pos;
-}
-public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {
 
-       // compound assignment extra work
-       if (isCompound) { // check the variable part is initialized if blank final
-               switch (bits & RestrictiveFlagMASK) {
-                       case FIELD : // reading a field
+       public SingleNameReference(char[] source, long pos) {
+               super();
+               token = source;
+               sourceStart = (int) (pos >>> 32);
+               sourceEnd = (int) pos;
+       }
+
+       public FlowInfo analyseAssignment(BlockScope currentScope,
+                       FlowContext flowContext, FlowInfo flowInfo, Assignment assignment,
+                       boolean isCompound) {
+
+               // compound assignment extra work
+               if (isCompound) { // check the variable part is initialized if blank
+                                                       // final
+                       switch (bits & RestrictiveFlagMASK) {
+                       case FIELD: // reading a field
                                FieldBinding fieldBinding;
-                               if ((fieldBinding = (FieldBinding) binding).isBlankFinal() 
-                                               && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
+                               if ((fieldBinding = (FieldBinding) binding).isBlankFinal()
+                                               && currentScope
+                                                               .allowBlankFinalFieldAssignment(fieldBinding)) {
                                        if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
-                                               currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
+                                               currentScope.problemReporter()
+                                                               .uninitializedBlankFinalField(fieldBinding,
+                                                                               this);
                                        }
                                }
                                manageSyntheticReadAccessIfNecessary(currentScope);
                                break;
-//                     case LOCAL : // reading a local variable
-//                             // check if assigning a final blank field
-//                             LocalVariableBinding localBinding;
-//                             if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
-//                                     currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
-//                                     // we could improve error msg here telling "cannot use compound assignment on final local variable"
-//                             }
-//                             if (flowInfo.isReachable()) {
-//                                     localBinding.useFlag = LocalVariableBinding.USED;
-//                             } else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
-//                                     localBinding.useFlag = LocalVariableBinding.FAKE_USED;
-//                             }
+                       // case LOCAL : // reading a local variable
+                       // // check if assigning a final blank field
+                       // LocalVariableBinding localBinding;
+                       // if (!flowInfo.isDefinitelyAssigned(localBinding =
+                       // (LocalVariableBinding) binding)) {
+                       // currentScope.problemReporter().uninitializedLocalVariable(localBinding,
+                       // this);
+                       // // we could improve error msg here telling "cannot use compound
+                       // assignment on final local variable"
+                       // }
+                       // if (flowInfo.isReachable()) {
+                       // localBinding.useFlag = LocalVariableBinding.USED;
+                       // } else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
+                       // localBinding.useFlag = LocalVariableBinding.FAKE_USED;
+                       // }
+                       }
                }
-       }
-       if (assignment.expression != null) {
-               flowInfo = assignment.expression.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
-       }
-       switch (bits & RestrictiveFlagMASK) {
-               case FIELD : // assigning to a field
+               if (assignment.expression != null) {
+                       flowInfo = assignment.expression.analyseCode(currentScope,
+                                       flowContext, flowInfo).unconditionalInits();
+               }
+               switch (bits & RestrictiveFlagMASK) {
+               case FIELD: // assigning to a field
                        manageSyntheticWriteAccessIfNecessary(currentScope);
 
                        // check if assigning a final field
                        FieldBinding fieldBinding;
                        if ((fieldBinding = (FieldBinding) binding).isFinal()) {
                                // inside a context where allowed
-                               if (!isCompound && fieldBinding.isBlankFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
+                               if (!isCompound
+                                               && fieldBinding.isBlankFinal()
+                                               && currentScope
+                                                               .allowBlankFinalFieldAssignment(fieldBinding)) {
                                        if (flowInfo.isPotentiallyAssigned(fieldBinding)) {
-                                               currentScope.problemReporter().duplicateInitializationOfBlankFinalField(fieldBinding, this);
+                                               currentScope.problemReporter()
+                                                               .duplicateInitializationOfBlankFinalField(
+                                                                               fieldBinding, this);
                                        } else {
-                                               flowContext.recordSettingFinal(fieldBinding, this);                                             
+                                               flowContext.recordSettingFinal(fieldBinding, this);
                                        }
                                        flowInfo.markAsDefinitelyAssigned(fieldBinding);
                                } else {
-                                       currentScope.problemReporter().cannotAssignToFinalField(fieldBinding, this);
+                                       currentScope.problemReporter().cannotAssignToFinalField(
+                                                       fieldBinding, this);
                                }
                        }
                        break;
-               case LOCAL : // assigning to a local variable 
+               case LOCAL: // assigning to a local variable
                        LocalVariableBinding localBinding = (LocalVariableBinding) binding;
-                       if (!flowInfo.isDefinitelyAssigned(localBinding)){// for local variable debug attributes
+                       if (!flowInfo.isDefinitelyAssigned(localBinding)) {// for local
+                                                                                                                               // variable
+                                                                                                                               // debug
+                                                                                                                               // attributes
                                bits |= FirstAssignmentToLocalMASK;
                        } else {
                                bits &= ~FirstAssignmentToLocalMASK;
                        }
                        if (localBinding.isFinal()) {
                                if ((bits & DepthMASK) == 0) {
-                                       if (isCompound || !localBinding.isBlankFinal()){
-                                               currentScope.problemReporter().cannotAssignToFinalLocal(localBinding, this);
+                                       if (isCompound || !localBinding.isBlankFinal()) {
+                                               currentScope.problemReporter()
+                                                               .cannotAssignToFinalLocal(localBinding, this);
                                        } else if (flowInfo.isPotentiallyAssigned(localBinding)) {
-                                               currentScope.problemReporter().duplicateInitializationOfFinalLocal(localBinding, this);
+                                               currentScope.problemReporter()
+                                                               .duplicateInitializationOfFinalLocal(
+                                                                               localBinding, this);
                                        } else {
-                                               flowContext.recordSettingFinal(localBinding, this);                                                             
+                                               flowContext.recordSettingFinal(localBinding, this);
                                        }
                                } else {
-                                       currentScope.problemReporter().cannotAssignToFinalOuterLocal(localBinding, this);
+                                       currentScope.problemReporter()
+                                                       .cannotAssignToFinalOuterLocal(localBinding, this);
                                }
                        }
                        flowInfo.markAsDefinitelyAssigned(localBinding);
+               }
+               manageEnclosingInstanceAccessIfNecessary(currentScope);
+               return flowInfo;
        }
-       manageEnclosingInstanceAccessIfNecessary(currentScope);
-       return flowInfo;
-}
-public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
-       return analyseCode(currentScope, flowContext, flowInfo, true);
-}
-public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
 
-       switch (bits & RestrictiveFlagMASK) {
-               case FIELD : // reading a field
+       public FlowInfo analyseCode(BlockScope currentScope,
+                       FlowContext flowContext, FlowInfo flowInfo) {
+               return analyseCode(currentScope, flowContext, flowInfo, true);
+       }
+
+       public FlowInfo analyseCode(BlockScope currentScope,
+                       FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
+
+               switch (bits & RestrictiveFlagMASK) {
+               case FIELD: // reading a field
                        if (valueRequired) {
                                manageSyntheticReadAccessIfNecessary(currentScope);
                        }
                        // check if reading a final blank field
                        FieldBinding fieldBinding;
-                       if ((fieldBinding = (FieldBinding) binding).isBlankFinal() 
-                                       && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
+                       if ((fieldBinding = (FieldBinding) binding).isBlankFinal()
+                                       && currentScope
+                                                       .allowBlankFinalFieldAssignment(fieldBinding)) {
                                if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
-                                       currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
+                                       currentScope.problemReporter()
+                                                       .uninitializedBlankFinalField(fieldBinding, this);
                                }
                        }
                        break;
-//             case LOCAL : // reading a local variable
-//                     LocalVariableBinding localBinding;
-//                     if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
-//                             currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
-//                     }
-//                     if (flowInfo.isReachable()) {
-//                             localBinding.useFlag = LocalVariableBinding.USED;
-//                     } else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
-//                             localBinding.useFlag = LocalVariableBinding.FAKE_USED;
-//                     }
-       }
-       if (valueRequired) {
-               manageEnclosingInstanceAccessIfNecessary(currentScope);
-       }
-       return flowInfo;
-}
-public TypeBinding checkFieldAccess(BlockScope scope) {
-
-       FieldBinding fieldBinding = (FieldBinding) binding;
-       
-       bits &= ~RestrictiveFlagMASK; // clear bits
-       bits |= FIELD;
-       if (!((FieldBinding) binding).isStatic()) {
-               // must check for the static status....
-               if (scope.methodScope().isStatic) {
-                       scope.problemReporter().staticFieldAccessToNonStaticVariable(this, fieldBinding);
-                       constant = NotAConstant;
-                       return fieldBinding.type;
+               // case LOCAL : // reading a local variable
+               // LocalVariableBinding localBinding;
+               // if (!flowInfo.isDefinitelyAssigned(localBinding =
+               // (LocalVariableBinding) binding)) {
+               // currentScope.problemReporter().uninitializedLocalVariable(localBinding,
+               // this);
+               // }
+               // if (flowInfo.isReachable()) {
+               // localBinding.useFlag = LocalVariableBinding.USED;
+               // } else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
+               // localBinding.useFlag = LocalVariableBinding.FAKE_USED;
+               // }
                }
+               if (valueRequired) {
+                       manageEnclosingInstanceAccessIfNecessary(currentScope);
+               }
+               return flowInfo;
        }
-       constant = FieldReference.getConstantFor(fieldBinding, this, true, scope);
-
-       if (isFieldUseDeprecated(fieldBinding, scope))
-               scope.problemReporter().deprecatedField(fieldBinding, this);
-
-       MethodScope ms = scope.methodScope();
-       if ((this.bits & IsStrictlyAssignedMASK) == 0
-               && ms.enclosingSourceType() == fieldBinding.declaringClass
-               && ms.fieldDeclarationIndex != MethodScope.NotInFieldDecl
-               && fieldBinding.id >= ms.fieldDeclarationIndex) {
-               //if the field is static and ms is not .... then it is valid
-               if (!fieldBinding.isStatic() || ms.isStatic)
-                       scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
-       }
-       //====================================================
 
-       return fieldBinding.type;
+       public TypeBinding checkFieldAccess(BlockScope scope) {
+
+               FieldBinding fieldBinding = (FieldBinding) binding;
+
+               bits &= ~RestrictiveFlagMASK; // clear bits
+               bits |= FIELD;
+               if (!((FieldBinding) binding).isStatic()) {
+                       // must check for the static status....
+                       if (scope.methodScope().isStatic) {
+                               scope.problemReporter().staticFieldAccessToNonStaticVariable(
+                                               this, fieldBinding);
+                               constant = NotAConstant;
+                               return fieldBinding.type;
+                       }
+               }
+               constant = FieldReference.getConstantFor(fieldBinding, this, true,
+                               scope);
+
+               if (isFieldUseDeprecated(fieldBinding, scope))
+                       scope.problemReporter().deprecatedField(fieldBinding, this);
+
+               MethodScope ms = scope.methodScope();
+               if ((this.bits & IsStrictlyAssignedMASK) == 0
+                               && ms.enclosingSourceType() == fieldBinding.declaringClass
+                               && ms.fieldDeclarationIndex != MethodScope.NotInFieldDecl
+                               && fieldBinding.id >= ms.fieldDeclarationIndex) {
+                       // if the field is static and ms is not .... then it is valid
+                       if (!fieldBinding.isStatic() || ms.isStatic)
+                               scope.problemReporter().forwardReference(this, 0,
+                                               scope.enclosingSourceType());
+               }
+               // ====================================================
+
+               return fieldBinding.type;
 
-}
-//public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {
-//
-//     // optimizing assignment like: i = i + 1 or i = 1 + i
-//     if (assignment.expression.isCompactableOperation()) {
-//             BinaryExpression operation = (BinaryExpression) assignment.expression;
-//             SingleNameReference variableReference;
-//             if ((operation.left instanceof SingleNameReference) && ((variableReference = (SingleNameReference) operation.left).binding == binding)) {
-//                     // i = i + value, then use the variable on the right hand side, since it has the correct implicit conversion
-//                     variableReference.generateCompoundAssignment(currentScope, codeStream, syntheticAccessors == null ? null : syntheticAccessors[WRITE], operation.right, (operation.bits & OperatorMASK) >> OperatorSHIFT, operation.left.implicitConversion /*should be equivalent to no conversion*/, valueRequired);
-//                     return;
-//             }
-//             int operator = (operation.bits & OperatorMASK) >> OperatorSHIFT;
-//             if ((operation.right instanceof SingleNameReference)
-//                     && ((operator == PLUS) || (operator == MULTIPLY)) // only commutative operations
-//                     && ((variableReference = (SingleNameReference) operation.right).binding == binding)
-//                     && (operation.left.constant != NotAConstant) // exclude non constant expressions, since could have side-effect
-//                     && ((operation.left.implicitConversion >> 4) != T_String) // exclude string concatenation which would occur backwards
-//                     && ((operation.right.implicitConversion >> 4) != T_String)) { // exclude string concatenation which would occur backwards
-//                     // i = value + i, then use the variable on the right hand side, since it has the correct implicit conversion
-//                     variableReference.generateCompoundAssignment(currentScope, codeStream, syntheticAccessors == null ? null : syntheticAccessors[WRITE], operation.left, operator, operation.right.implicitConversion /*should be equivalent to no conversion*/, valueRequired);
-//                     return;
-//             }
-//     }
-//     switch (bits & RestrictiveFlagMASK) {
-//             case FIELD : // assigning to a field
-//                     FieldBinding fieldBinding;
-//                     if (!(fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) { // need a receiver?
-//                             if ((bits & DepthMASK) != 0) {
-//                                     ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
-//                                     Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
-//                                     codeStream.generateOuterAccess(emulationPath, this, targetType, currentScope);
-//                             } else {
-//                                     this.generateReceiver(codeStream);
-//                             }
-//                     }
-//                     assignment.expression.generateCode(currentScope, codeStream, true);
-//                     fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null : syntheticAccessors[WRITE], valueRequired);
-//                     if (valueRequired) {
-//                             codeStream.generateImplicitConversion(assignment.implicitConversion);
-//                     }
-//                     return;
-//             case LOCAL : // assigning to a local variable
-//                     LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
-//                     if (localBinding.resolvedPosition != -1) {
-//                             assignment.expression.generateCode(currentScope, codeStream, true);
-//                     } else {
-//                             if (assignment.expression.constant != NotAConstant) {
-//                                     // assigning an unused local to a constant value = no actual assignment is necessary
-//                                     if (valueRequired) {
-//                                             codeStream.generateConstant(assignment.expression.constant, assignment.implicitConversion);
-//                                     }
-//                             } else {
-//                                     assignment.expression.generateCode(currentScope, codeStream, true);
-//                                     /* Even though the value may not be required, we force it to be produced, and discard it later
-//                                     on if it was actually not necessary, so as to provide the same behavior as JDK1.2beta3. */
-//                                     if (valueRequired) {
-//                                             codeStream.generateImplicitConversion(assignment.implicitConversion); // implicit conversion
-//                                     } else {
-//                                             if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
-//                                                     codeStream.pop2();
-//                                             } else {
-//                                                     codeStream.pop();
-//                                             }
-//                                     }
-//                             }
-//                             return;
-//                     }
-//                     // 26903, need extra cast to store null in array local var      
-//                     if (localBinding.type.isArrayType() 
-//                             && (assignment.expression.resolvedType == NullBinding   // arrayLoc = null
-//                                     || ((assignment.expression instanceof CastExpression)   // arrayLoc = (type[])null
-//                                             && (((CastExpression)assignment.expression).innermostCastedExpression().resolvedType == NullBinding)))){
-//                             codeStream.checkcast(localBinding.type); 
-//                     }
-//                     
-//                     // normal local assignment (since cannot store in outer local which are final locations)
-//                     codeStream.store(localBinding, valueRequired);
-//                     if ((bits & FirstAssignmentToLocalMASK) != 0) { // for local variable debug attributes
-//                             localBinding.recordInitializationStartPC(codeStream.position);
-//                     }
-//                     // implicit conversion
-//                     if (valueRequired) {
-//                             codeStream.generateImplicitConversion(assignment.implicitConversion);
-//                     }
-//     }
-//}
-//public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
-//     int pc = codeStream.position;
-//     if (constant != NotAConstant) {
-//             if (valueRequired) {
-//                     codeStream.generateConstant(constant, implicitConversion);
-//             }
-//     } else {
-//             switch (bits & RestrictiveFlagMASK) {
-//                     case FIELD : // reading a field
-//                             FieldBinding fieldBinding;
-//                             if (valueRequired) {
-//                                     if ((fieldBinding = (FieldBinding) this.codegenBinding).constant == NotAConstant) { // directly use inlined value for constant fields
-//                                             boolean isStatic;
-//                                             if (!(isStatic = fieldBinding.isStatic())) {
-//                                                     if ((bits & DepthMASK) != 0) {
-//                                                             ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
-//                                                             Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
-//                                                             codeStream.generateOuterAccess(emulationPath, this, targetType, currentScope);
-//                                                     } else {
-//                                                             generateReceiver(codeStream);
-//                                                     }
-//                                             }
-//                                             // managing private access                                                      
-//                                             if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
-//                                                     if (isStatic) {
-//                                                             codeStream.getstatic(fieldBinding);
-//                                                     } else {
-//                                                             codeStream.getfield(fieldBinding);
-//                                                     }
-//                                             } else {
-//                                                     codeStream.invokestatic(syntheticAccessors[READ]);
-//                                             }
-//                                             codeStream.generateImplicitConversion(implicitConversion);
-//                                     } else { // directly use the inlined value
-//                                             codeStream.generateConstant(fieldBinding.constant, implicitConversion);
-//                                     }
-//                             }
-//                             break;
-//                     case LOCAL : // reading a local
-//                             LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
-//                             if (valueRequired) {
-//                                     // outer local?
-//                                     if ((bits & DepthMASK) != 0) {
-//                                             // outer local can be reached either through a synthetic arg or a synthetic field
-//                                             VariableBinding[] path = currentScope.getEmulationPath(localBinding);
-//                                             codeStream.generateOuterAccess(path, this, localBinding, currentScope);
-//                                     } else {
-//                                             // regular local variable read
-//                                             codeStream.load(localBinding);
-//                                     }
-//                                     codeStream.generateImplicitConversion(implicitConversion);
-//                             }
-//             }
-//     }
-//     codeStream.recordPositionsFrom(pc, this.sourceStart);
-//}
-///*
-// * Regular API for compound assignment, relies on the fact that there is only one reference to the
-// * variable, which carries both synthetic read/write accessors.
-// * The APIs with an extra argument is used whenever there are two references to the same variable which
-// * are optimized in one access: e.g "a = a + 1" optimized into "a++".
-// */
-//public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
-//
-//     this.generateCompoundAssignment(
-//             currentScope, 
-//             codeStream, 
-//             syntheticAccessors == null ? null : syntheticAccessors[WRITE],
-//             expression,
-//             operator, 
-//             assignmentImplicitConversion, 
-//             valueRequired);
-//}
-///*
-// * The APIs with an extra argument is used whenever there are two references to the same variable which
-// * are optimized in one access: e.g "a = a + 1" optimized into "a++".
-// */
-//public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, MethodBinding writeAccessor, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
-//     switch (bits & RestrictiveFlagMASK) {
-//             case FIELD : // assigning to a field
-//                     FieldBinding fieldBinding;
-//                     if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
-//                             if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
-//                                     codeStream.getstatic(fieldBinding);
-//                             } else {
-//                                     codeStream.invokestatic(syntheticAccessors[READ]);
-//                             }
-//                     } else {
-//                             if ((bits & DepthMASK) != 0) {
-//                                     ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
-//                                     Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
-//                                     codeStream.generateOuterAccess(emulationPath, this, targetType, currentScope);
-//                             } else {
-//                                     codeStream.aload_0();
-//                             }
-//                             codeStream.dup();
-//                             if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
-//                                     codeStream.getfield(fieldBinding);
-//                             } else {
-//                                     codeStream.invokestatic(syntheticAccessors[READ]);
-//                             }
-//                     }
-//                     break;
-//             case LOCAL : // assigning to a local variable (cannot assign to outer local)
-//                     LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
-//                     Constant assignConstant;
-//                     int increment;
-//                     // using incr bytecode if possible
-//                     switch (localBinding.type.id) {
-//                             case T_String :
-//                                     codeStream.generateStringAppend(currentScope, this, expression);
-//                                     if (valueRequired) {
-//                                             codeStream.dup();
-//                                     }
-//                                     codeStream.store(localBinding, false);
-//                                     return;
-//                             case T_int :
-//                                     if (((assignConstant = expression.constant) != NotAConstant) 
-//                                             && (assignConstant.typeID() != T_float) // only for integral types
-//                                             && (assignConstant.typeID() != T_double)
-//                                             && ((increment = assignConstant.intValue()) == (short) increment)) { // 16 bits value
-//                                             switch (operator) {
-//                                                     case PLUS :
-//                                                             codeStream.iinc(localBinding.resolvedPosition, increment);
-//                                                             if (valueRequired) {
-//                                                                     codeStream.load(localBinding);
-//                                                             }
-//                                                             return;
-//                                                     case MINUS :
-//                                                             codeStream.iinc(localBinding.resolvedPosition, -increment);
-//                                                             if (valueRequired) {
-//                                                                     codeStream.load(localBinding);
-//                                                             }
-//                                                             return;
-//                                             }
-//                                     }
-//                             default :
-//                                     codeStream.load(localBinding);
-//                     }
-//     }
-//     // perform the actual compound operation
-//     int operationTypeID;
-//     if ((operationTypeID = implicitConversion >> 4) == T_String || operationTypeID == T_Object) {
-//             // we enter here if the single name reference is a field of type java.lang.String or if the type of the 
-//             // operation is java.lang.Object
-//             // For example: o = o + ""; // where the compiled type of o is java.lang.Object.
-//             codeStream.generateStringAppend(currentScope, null, expression);
-//     } else {
-//             // promote the array reference to the suitable operation type
-//             codeStream.generateImplicitConversion(implicitConversion);
-//             // generate the increment value (will by itself  be promoted to the operation value)
-//             if (expression == IntLiteral.One){ // prefix operation
-//                     codeStream.generateConstant(expression.constant, implicitConversion);                   
-//             } else {
-//                     expression.generateCode(currentScope, codeStream, true);
-//             }               
-//             // perform the operation
-//             codeStream.sendOperator(operator, operationTypeID);
-//             // cast the value back to the array reference type
-//             codeStream.generateImplicitConversion(assignmentImplicitConversion);
-//     }
-//     // store the result back into the variable
-//     switch (bits & RestrictiveFlagMASK) {
-//             case FIELD : // assigning to a field
-//                     fieldStore(codeStream, (FieldBinding) this.codegenBinding, writeAccessor, valueRequired);
-//                     return;
-//             case LOCAL : // assigning to a local variable
-//                     LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
-//                     if (valueRequired) {
-//                             if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
-//                                     codeStream.dup2();
-//                             } else {
-//                                     codeStream.dup();
-//                             }
-//                     }
-//                     codeStream.store(localBinding, false);
-//     }
-//}
-//public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
-//     switch (bits & RestrictiveFlagMASK) {
-//             case FIELD : // assigning to a field
-//                     FieldBinding fieldBinding;
-//                     if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
-//                             if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
-//                                     codeStream.getstatic(fieldBinding);
-//                             } else {
-//                                     codeStream.invokestatic(syntheticAccessors[READ]);
-//                             }
-//                     } else {
-//                             if ((bits & DepthMASK) != 0) {
-//                                     ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
-//                                     Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
-//                                     codeStream.generateOuterAccess(emulationPath, this, targetType, currentScope);
-//                             } else {
-//                                     codeStream.aload_0();
-//                             }
-//                             codeStream.dup();
-//                             if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
-//                                     codeStream.getfield(fieldBinding);
-//                             } else {
-//                                     codeStream.invokestatic(syntheticAccessors[READ]);
-//                             }
-//                     }
-//                     if (valueRequired) {
-//                             if (fieldBinding.isStatic()) {
-//                                     if ((fieldBinding.type == LongBinding) || (fieldBinding.type == DoubleBinding)) {
-//                                             codeStream.dup2();
-//                                     } else {
-//                                             codeStream.dup();
-//                                     }
-//                             } else { // Stack:  [owner][old field value]  ---> [old field value][owner][old field value]
-//                                     if ((fieldBinding.type == LongBinding) || (fieldBinding.type == DoubleBinding)) {
-//                                             codeStream.dup2_x1();
-//                                     } else {
-//                                             codeStream.dup_x1();
-//                                     }
-//                             }
-//                     }
-//                     codeStream.generateConstant(postIncrement.expression.constant, implicitConversion);
-//                     codeStream.sendOperator(postIncrement.operator, fieldBinding.type.id);
-//                     codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
-//                     fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null : syntheticAccessors[WRITE], false);
-//                     return;
-//             case LOCAL : // assigning to a local variable
-//                     LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
-//                     // using incr bytecode if possible
-//                     if (localBinding.type == IntBinding) {
-//                             if (valueRequired) {
-//                                     codeStream.load(localBinding);
-//                             }
-//                             if (postIncrement.operator == PLUS) {
-//                                     codeStream.iinc(localBinding.resolvedPosition, 1);
-//                             } else {
-//                                     codeStream.iinc(localBinding.resolvedPosition, -1);
-//                             }
-//                     } else {
-//                             codeStream.load(localBinding);
-//                             if (valueRequired){
-//                                     if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
-//                                             codeStream.dup2();
-//                                     } else {
-//                                             codeStream.dup();
-//                                     }
-//                             }
-//                             codeStream.generateConstant(postIncrement.expression.constant, implicitConversion);
-//                             codeStream.sendOperator(postIncrement.operator, localBinding.type.id);
-//                             codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
-//
-//                             codeStream.store(localBinding, false);
-//                     }
-//     }
-//}
-//public void generateReceiver(CodeStream codeStream) {
-//     codeStream.aload_0();
-//}
-public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {
-
-       //If inlinable field, forget the access emulation, the code gen will directly target it
-       if (((bits & DepthMASK) == 0) || (constant != NotAConstant)) return;
-
-       if ((bits & RestrictiveFlagMASK) == LOCAL) {
-               currentScope.emulateOuterAccess((LocalVariableBinding) binding);
        }
-}
-public void manageSyntheticReadAccessIfNecessary(BlockScope currentScope) {
 
-       //If inlinable field, forget the access emulation, the code gen will directly target it
-       if (constant != NotAConstant)
-               return;
+       // public void generateAssignment(BlockScope currentScope, CodeStream
+       // codeStream, Assignment assignment, boolean valueRequired) {
+       //
+       // // optimizing assignment like: i = i + 1 or i = 1 + i
+       // if (assignment.expression.isCompactableOperation()) {
+       // BinaryExpression operation = (BinaryExpression) assignment.expression;
+       // SingleNameReference variableReference;
+       // if ((operation.left instanceof SingleNameReference) &&
+       // ((variableReference = (SingleNameReference) operation.left).binding ==
+       // binding)) {
+       // // i = i + value, then use the variable on the right hand side, since it
+       // has the correct implicit conversion
+       // variableReference.generateCompoundAssignment(currentScope, codeStream,
+       // syntheticAccessors == null ? null : syntheticAccessors[WRITE],
+       // operation.right, (operation.bits & OperatorMASK) >> OperatorSHIFT,
+       // operation.left.implicitConversion /*should be equivalent to no
+       // conversion*/, valueRequired);
+       // return;
+       // }
+       // int operator = (operation.bits & OperatorMASK) >> OperatorSHIFT;
+       // if ((operation.right instanceof SingleNameReference)
+       // && ((operator == PLUS) || (operator == MULTIPLY)) // only commutative
+       // operations
+       // && ((variableReference = (SingleNameReference) operation.right).binding
+       // == binding)
+       // && (operation.left.constant != NotAConstant) // exclude non constant
+       // expressions, since could have side-effect
+       // && ((operation.left.implicitConversion >> 4) != T_String) // exclude
+       // string concatenation which would occur backwards
+       // && ((operation.right.implicitConversion >> 4) != T_String)) { // exclude
+       // string concatenation which would occur backwards
+       // // i = value + i, then use the variable on the right hand side, since it
+       // has the correct implicit conversion
+       // variableReference.generateCompoundAssignment(currentScope, codeStream,
+       // syntheticAccessors == null ? null : syntheticAccessors[WRITE],
+       // operation.left, operator, operation.right.implicitConversion /*should be
+       // equivalent to no conversion*/, valueRequired);
+       // return;
+       // }
+       // }
+       // switch (bits & RestrictiveFlagMASK) {
+       // case FIELD : // assigning to a field
+       // FieldBinding fieldBinding;
+       // if (!(fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) { //
+       // need a receiver?
+       // if ((bits & DepthMASK) != 0) {
+       // ReferenceBinding targetType =
+       // currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >>
+       // DepthSHIFT);
+       // Object[] emulationPath = currentScope.getEmulationPath(targetType, true
+       // /*only exact match*/, false/*consider enclosing arg*/);
+       // codeStream.generateOuterAccess(emulationPath, this, targetType,
+       // currentScope);
+       // } else {
+       // this.generateReceiver(codeStream);
+       // }
+       // }
+       // assignment.expression.generateCode(currentScope, codeStream, true);
+       // fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null :
+       // syntheticAccessors[WRITE], valueRequired);
+       // if (valueRequired) {
+       // codeStream.generateImplicitConversion(assignment.implicitConversion);
+       // }
+       // return;
+       // case LOCAL : // assigning to a local variable
+       // LocalVariableBinding localBinding = (LocalVariableBinding)
+       // this.codegenBinding;
+       // if (localBinding.resolvedPosition != -1) {
+       // assignment.expression.generateCode(currentScope, codeStream, true);
+       // } else {
+       // if (assignment.expression.constant != NotAConstant) {
+       // // assigning an unused local to a constant value = no actual assignment
+       // is necessary
+       // if (valueRequired) {
+       // codeStream.generateConstant(assignment.expression.constant,
+       // assignment.implicitConversion);
+       // }
+       // } else {
+       // assignment.expression.generateCode(currentScope, codeStream, true);
+       // /* Even though the value may not be required, we force it to be produced,
+       // and discard it later
+       // on if it was actually not necessary, so as to provide the same behavior
+       // as JDK1.2beta3. */
+       // if (valueRequired) {
+       // codeStream.generateImplicitConversion(assignment.implicitConversion); //
+       // implicit conversion
+       // } else {
+       // if ((localBinding.type == LongBinding) || (localBinding.type ==
+       // DoubleBinding)) {
+       // codeStream.pop2();
+       // } else {
+       // codeStream.pop();
+       // }
+       // }
+       // }
+       // return;
+       // }
+       // // 26903, need extra cast to store null in array local var
+       // if (localBinding.type.isArrayType()
+       // && (assignment.expression.resolvedType == NullBinding // arrayLoc = null
+       // || ((assignment.expression instanceof CastExpression) // arrayLoc =
+       // (type[])null
+       // &&
+       // (((CastExpression)assignment.expression).innermostCastedExpression().resolvedType
+       // == NullBinding)))){
+       // codeStream.checkcast(localBinding.type);
+       // }
+       //                      
+       // // normal local assignment (since cannot store in outer local which are
+       // final locations)
+       // codeStream.store(localBinding, valueRequired);
+       // if ((bits & FirstAssignmentToLocalMASK) != 0) { // for local variable
+       // debug attributes
+       // localBinding.recordInitializationStartPC(codeStream.position);
+       // }
+       // // implicit conversion
+       // if (valueRequired) {
+       // codeStream.generateImplicitConversion(assignment.implicitConversion);
+       // }
+       // }
+       // }
+       // public void generateCode(BlockScope currentScope, CodeStream codeStream,
+       // boolean valueRequired) {
+       // int pc = codeStream.position;
+       // if (constant != NotAConstant) {
+       // if (valueRequired) {
+       // codeStream.generateConstant(constant, implicitConversion);
+       // }
+       // } else {
+       // switch (bits & RestrictiveFlagMASK) {
+       // case FIELD : // reading a field
+       // FieldBinding fieldBinding;
+       // if (valueRequired) {
+       // if ((fieldBinding = (FieldBinding) this.codegenBinding).constant ==
+       // NotAConstant) { // directly use inlined value for constant fields
+       // boolean isStatic;
+       // if (!(isStatic = fieldBinding.isStatic())) {
+       // if ((bits & DepthMASK) != 0) {
+       // ReferenceBinding targetType =
+       // currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >>
+       // DepthSHIFT);
+       // Object[] emulationPath = currentScope.getEmulationPath(targetType, true
+       // /*only exact match*/, false/*consider enclosing arg*/);
+       // codeStream.generateOuterAccess(emulationPath, this, targetType,
+       // currentScope);
+       // } else {
+       // generateReceiver(codeStream);
+       // }
+       // }
+       // // managing private access
+       // if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
+       // if (isStatic) {
+       // codeStream.getstatic(fieldBinding);
+       // } else {
+       // codeStream.getfield(fieldBinding);
+       // }
+       // } else {
+       // codeStream.invokestatic(syntheticAccessors[READ]);
+       // }
+       // codeStream.generateImplicitConversion(implicitConversion);
+       // } else { // directly use the inlined value
+       // codeStream.generateConstant(fieldBinding.constant, implicitConversion);
+       // }
+       // }
+       // break;
+       // case LOCAL : // reading a local
+       // LocalVariableBinding localBinding = (LocalVariableBinding)
+       // this.codegenBinding;
+       // if (valueRequired) {
+       // // outer local?
+       // if ((bits & DepthMASK) != 0) {
+       // // outer local can be reached either through a synthetic arg or a
+       // synthetic field
+       // VariableBinding[] path = currentScope.getEmulationPath(localBinding);
+       // codeStream.generateOuterAccess(path, this, localBinding, currentScope);
+       // } else {
+       // // regular local variable read
+       // codeStream.load(localBinding);
+       // }
+       // codeStream.generateImplicitConversion(implicitConversion);
+       // }
+       // }
+       // }
+       // codeStream.recordPositionsFrom(pc, this.sourceStart);
+       // }
+       // /*
+       // * Regular API for compound assignment, relies on the fact that there is
+       // only one reference to the
+       // * variable, which carries both synthetic read/write accessors.
+       // * The APIs with an extra argument is used whenever there are two
+       // references to the same variable which
+       // * are optimized in one access: e.g "a = a + 1" optimized into "a++".
+       // */
+       // public void generateCompoundAssignment(BlockScope currentScope,
+       // CodeStream codeStream, Expression expression, int operator, int
+       // assignmentImplicitConversion, boolean valueRequired) {
+       //
+       // this.generateCompoundAssignment(
+       // currentScope,
+       // codeStream,
+       // syntheticAccessors == null ? null : syntheticAccessors[WRITE],
+       // expression,
+       // operator,
+       // assignmentImplicitConversion,
+       // valueRequired);
+       // }
+       // /*
+       // * The APIs with an extra argument is used whenever there are two
+       // references to the same variable which
+       // * are optimized in one access: e.g "a = a + 1" optimized into "a++".
+       // */
+       // public void generateCompoundAssignment(BlockScope currentScope,
+       // CodeStream codeStream, MethodBinding writeAccessor, Expression
+       // expression, int operator, int assignmentImplicitConversion, boolean
+       // valueRequired) {
+       // switch (bits & RestrictiveFlagMASK) {
+       // case FIELD : // assigning to a field
+       // FieldBinding fieldBinding;
+       // if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
+       // if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
+       // codeStream.getstatic(fieldBinding);
+       // } else {
+       // codeStream.invokestatic(syntheticAccessors[READ]);
+       // }
+       // } else {
+       // if ((bits & DepthMASK) != 0) {
+       // ReferenceBinding targetType =
+       // currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >>
+       // DepthSHIFT);
+       // Object[] emulationPath = currentScope.getEmulationPath(targetType, true
+       // /*only exact match*/, false/*consider enclosing arg*/);
+       // codeStream.generateOuterAccess(emulationPath, this, targetType,
+       // currentScope);
+       // } else {
+       // codeStream.aload_0();
+       // }
+       // codeStream.dup();
+       // if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
+       // codeStream.getfield(fieldBinding);
+       // } else {
+       // codeStream.invokestatic(syntheticAccessors[READ]);
+       // }
+       // }
+       // break;
+       // case LOCAL : // assigning to a local variable (cannot assign to outer
+       // local)
+       // LocalVariableBinding localBinding = (LocalVariableBinding)
+       // this.codegenBinding;
+       // Constant assignConstant;
+       // int increment;
+       // // using incr bytecode if possible
+       // switch (localBinding.type.id) {
+       // case T_String :
+       // codeStream.generateStringAppend(currentScope, this, expression);
+       // if (valueRequired) {
+       // codeStream.dup();
+       // }
+       // codeStream.store(localBinding, false);
+       // return;
+       // case T_int :
+       // if (((assignConstant = expression.constant) != NotAConstant)
+       // && (assignConstant.typeID() != T_float) // only for integral types
+       // && (assignConstant.typeID() != T_double)
+       // && ((increment = assignConstant.intValue()) == (short) increment)) { //
+       // 16 bits value
+       // switch (operator) {
+       // case PLUS :
+       // codeStream.iinc(localBinding.resolvedPosition, increment);
+       // if (valueRequired) {
+       // codeStream.load(localBinding);
+       // }
+       // return;
+       // case MINUS :
+       // codeStream.iinc(localBinding.resolvedPosition, -increment);
+       // if (valueRequired) {
+       // codeStream.load(localBinding);
+       // }
+       // return;
+       // }
+       // }
+       // default :
+       // codeStream.load(localBinding);
+       // }
+       // }
+       // // perform the actual compound operation
+       // int operationTypeID;
+       // if ((operationTypeID = implicitConversion >> 4) == T_String ||
+       // operationTypeID == T_Object) {
+       // // we enter here if the single name reference is a field of type
+       // java.lang.String or if the type of the
+       // // operation is java.lang.Object
+       // // For example: o = o + ""; // where the compiled type of o is
+       // java.lang.Object.
+       // codeStream.generateStringAppend(currentScope, null, expression);
+       // } else {
+       // // promote the array reference to the suitable operation type
+       // codeStream.generateImplicitConversion(implicitConversion);
+       // // generate the increment value (will by itself be promoted to the
+       // operation value)
+       // if (expression == IntLiteral.One){ // prefix operation
+       // codeStream.generateConstant(expression.constant, implicitConversion);
+       // } else {
+       // expression.generateCode(currentScope, codeStream, true);
+       // }
+       // // perform the operation
+       // codeStream.sendOperator(operator, operationTypeID);
+       // // cast the value back to the array reference type
+       // codeStream.generateImplicitConversion(assignmentImplicitConversion);
+       // }
+       // // store the result back into the variable
+       // switch (bits & RestrictiveFlagMASK) {
+       // case FIELD : // assigning to a field
+       // fieldStore(codeStream, (FieldBinding) this.codegenBinding, writeAccessor,
+       // valueRequired);
+       // return;
+       // case LOCAL : // assigning to a local variable
+       // LocalVariableBinding localBinding = (LocalVariableBinding)
+       // this.codegenBinding;
+       // if (valueRequired) {
+       // if ((localBinding.type == LongBinding) || (localBinding.type ==
+       // DoubleBinding)) {
+       // codeStream.dup2();
+       // } else {
+       // codeStream.dup();
+       // }
+       // }
+       // codeStream.store(localBinding, false);
+       // }
+       // }
+       // public void generatePostIncrement(BlockScope currentScope, CodeStream
+       // codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
+       // switch (bits & RestrictiveFlagMASK) {
+       // case FIELD : // assigning to a field
+       // FieldBinding fieldBinding;
+       // if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
+       // if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
+       // codeStream.getstatic(fieldBinding);
+       // } else {
+       // codeStream.invokestatic(syntheticAccessors[READ]);
+       // }
+       // } else {
+       // if ((bits & DepthMASK) != 0) {
+       // ReferenceBinding targetType =
+       // currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >>
+       // DepthSHIFT);
+       // Object[] emulationPath = currentScope.getEmulationPath(targetType, true
+       // /*only exact match*/, false/*consider enclosing arg*/);
+       // codeStream.generateOuterAccess(emulationPath, this, targetType,
+       // currentScope);
+       // } else {
+       // codeStream.aload_0();
+       // }
+       // codeStream.dup();
+       // if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
+       // codeStream.getfield(fieldBinding);
+       // } else {
+       // codeStream.invokestatic(syntheticAccessors[READ]);
+       // }
+       // }
+       // if (valueRequired) {
+       // if (fieldBinding.isStatic()) {
+       // if ((fieldBinding.type == LongBinding) || (fieldBinding.type ==
+       // DoubleBinding)) {
+       // codeStream.dup2();
+       // } else {
+       // codeStream.dup();
+       // }
+       // } else { // Stack: [owner][old field value] ---> [old field
+       // value][owner][old field value]
+       // if ((fieldBinding.type == LongBinding) || (fieldBinding.type ==
+       // DoubleBinding)) {
+       // codeStream.dup2_x1();
+       // } else {
+       // codeStream.dup_x1();
+       // }
+       // }
+       // }
+       // codeStream.generateConstant(postIncrement.expression.constant,
+       // implicitConversion);
+       // codeStream.sendOperator(postIncrement.operator, fieldBinding.type.id);
+       // codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
+       // fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null :
+       // syntheticAccessors[WRITE], false);
+       // return;
+       // case LOCAL : // assigning to a local variable
+       // LocalVariableBinding localBinding = (LocalVariableBinding)
+       // this.codegenBinding;
+       // // using incr bytecode if possible
+       // if (localBinding.type == IntBinding) {
+       // if (valueRequired) {
+       // codeStream.load(localBinding);
+       // }
+       // if (postIncrement.operator == PLUS) {
+       // codeStream.iinc(localBinding.resolvedPosition, 1);
+       // } else {
+       // codeStream.iinc(localBinding.resolvedPosition, -1);
+       // }
+       // } else {
+       // codeStream.load(localBinding);
+       // if (valueRequired){
+       // if ((localBinding.type == LongBinding) || (localBinding.type ==
+       // DoubleBinding)) {
+       // codeStream.dup2();
+       // } else {
+       // codeStream.dup();
+       // }
+       // }
+       // codeStream.generateConstant(postIncrement.expression.constant,
+       // implicitConversion);
+       // codeStream.sendOperator(postIncrement.operator, localBinding.type.id);
+       // codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
+       //
+       // codeStream.store(localBinding, false);
+       // }
+       // }
+       // }
+       // public void generateReceiver(CodeStream codeStream) {
+       // codeStream.aload_0();
+       // }
+       public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {
 
-       if ((bits & FIELD) != 0) {
-               FieldBinding fieldBinding = (FieldBinding) binding;
-               if (((bits & DepthMASK) != 0)
-                       && (fieldBinding.isPrivate() // private access
-                               || (fieldBinding.isProtected() // implicit protected access
-                                               && fieldBinding.declaringClass.getPackage() 
-                                                       != currentScope.enclosingSourceType().getPackage()))) {
-                       if (syntheticAccessors == null)
-                               syntheticAccessors = new MethodBinding[2];
-                       syntheticAccessors[READ] = 
-                               ((SourceTypeBinding)currentScope.enclosingSourceType().
-                                       enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT)).
-                                               addSyntheticMethod(fieldBinding, true);
-                       currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
+               // If inlinable field, forget the access emulation, the code gen will
+               // directly target it
+               if (((bits & DepthMASK) == 0) || (constant != NotAConstant))
                        return;
+
+               if ((bits & RestrictiveFlagMASK) == LOCAL) {
+                       currentScope.emulateOuterAccess((LocalVariableBinding) binding);
                }
-               // if the binding declaring class is not visible, need special action
-               // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
-               // NOTE: from target 1.2 on, field's declaring class is touched if any different from receiver type
-               // and not from Object or implicit static field access. 
-//             if (fieldBinding.declaringClass != this.actualReceiverType
-//                     && !this.actualReceiverType.isArrayType()       
-//                     && fieldBinding.declaringClass != null
-//                     && fieldBinding.constant == NotAConstant
-//                     && ((currentScope.environment().options.targetJDK >= CompilerOptions.JDK1_2 
-//                                     && !fieldBinding.isStatic()
-//                                     && fieldBinding.declaringClass.id != T_Object) // no change for Object fields (if there was any)
-//                             || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
-//                     this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)this.actualReceiverType);
-//             }
        }
-}
-public void manageSyntheticWriteAccessIfNecessary(BlockScope currentScope) {
 
-       if ((bits & FIELD) != 0) {
-               FieldBinding fieldBinding = (FieldBinding) binding;
-               if (((bits & DepthMASK) != 0) 
-                       && (fieldBinding.isPrivate() // private access
-                               || (fieldBinding.isProtected() // implicit protected access
-                                               && fieldBinding.declaringClass.getPackage() 
-                                                       != currentScope.enclosingSourceType().getPackage()))) {
-                       if (syntheticAccessors == null)
-                               syntheticAccessors = new MethodBinding[2];
-                       syntheticAccessors[WRITE] = 
-                               ((SourceTypeBinding)currentScope.enclosingSourceType().
-                                       enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT)).
-                                               addSyntheticMethod(fieldBinding, false);
-                       currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
+       public void manageSyntheticReadAccessIfNecessary(BlockScope currentScope) {
+
+               // If inlinable field, forget the access emulation, the code gen will
+               // directly target it
+               if (constant != NotAConstant)
                        return;
+
+               if ((bits & FIELD) != 0) {
+                       FieldBinding fieldBinding = (FieldBinding) binding;
+                       if (((bits & DepthMASK) != 0) && (fieldBinding.isPrivate() // private
+                                                                                                                                               // access
+                                       || (fieldBinding.isProtected() // implicit protected access
+                                       && fieldBinding.declaringClass.getPackage() != currentScope
+                                                       .enclosingSourceType().getPackage()))) {
+                               if (syntheticAccessors == null)
+                                       syntheticAccessors = new MethodBinding[2];
+                               syntheticAccessors[READ] = ((SourceTypeBinding) currentScope
+                                               .enclosingSourceType().enclosingTypeAt(
+                                                               (bits & DepthMASK) >> DepthSHIFT))
+                                               .addSyntheticMethod(fieldBinding, true);
+                               currentScope.problemReporter().needToEmulateFieldReadAccess(
+                                               fieldBinding, this);
+                               return;
+                       }
+                       // if the binding declaring class is not visible, need special
+                       // action
+                       // for runtime compatibility on 1.2 VMs : change the declaring class
+                       // of the binding
+                       // NOTE: from target 1.2 on, field's declaring class is touched if
+                       // any different from receiver type
+                       // and not from Object or implicit static field access.
+                       // if (fieldBinding.declaringClass != this.actualReceiverType
+                       // && !this.actualReceiverType.isArrayType()
+                       // && fieldBinding.declaringClass != null
+                       // && fieldBinding.constant == NotAConstant
+                       // && ((currentScope.environment().options.targetJDK >=
+                       // CompilerOptions.JDK1_2
+                       // && !fieldBinding.isStatic()
+                       // && fieldBinding.declaringClass.id != T_Object) // no change for
+                       // Object fields (if there was any)
+                       // || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
+                       // this.codegenBinding =
+                       // currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding,
+                       // (ReferenceBinding)this.actualReceiverType);
+                       // }
                }
-               // if the binding declaring class is not visible, need special action
-               // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
-               // NOTE: from target 1.2 on, field's declaring class is touched if any different from receiver type
-               // and not from Object or implicit static field access. 
-//             if (fieldBinding.declaringClass != this.actualReceiverType
-//                     && !this.actualReceiverType.isArrayType()       
-//                     && fieldBinding.declaringClass != null
-//                     && fieldBinding.constant == NotAConstant
-//                     && ((currentScope.environment().options.targetJDK >= CompilerOptions.JDK1_2 
-//                                     && !fieldBinding.isStatic()
-//                                     && fieldBinding.declaringClass.id != T_Object) // no change for Object fields (if there was any)
-//                             || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
-//                     this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)this.actualReceiverType);
-//             }
        }
-}
-public TypeBinding reportError(BlockScope scope) {
-       //=====error cases=======
-       constant = Constant.NotAConstant;
-       if (binding instanceof ProblemFieldBinding) {
-               scope.problemReporter().invalidField(this, (FieldBinding) binding);
-       } else if (binding instanceof ProblemReferenceBinding) {
-               scope.problemReporter().invalidType(this, (TypeBinding) binding);
-       } else {
-               scope.problemReporter().unresolvableReference(this, binding);
+
+       public void manageSyntheticWriteAccessIfNecessary(BlockScope currentScope) {
+
+               if ((bits & FIELD) != 0) {
+                       FieldBinding fieldBinding = (FieldBinding) binding;
+                       if (((bits & DepthMASK) != 0) && (fieldBinding.isPrivate() // private
+                                                                                                                                               // access
+                                       || (fieldBinding.isProtected() // implicit protected access
+                                       && fieldBinding.declaringClass.getPackage() != currentScope
+                                                       .enclosingSourceType().getPackage()))) {
+                               if (syntheticAccessors == null)
+                                       syntheticAccessors = new MethodBinding[2];
+                               syntheticAccessors[WRITE] = ((SourceTypeBinding) currentScope
+                                               .enclosingSourceType().enclosingTypeAt(
+                                                               (bits & DepthMASK) >> DepthSHIFT))
+                                               .addSyntheticMethod(fieldBinding, false);
+                               currentScope.problemReporter().needToEmulateFieldWriteAccess(
+                                               fieldBinding, this);
+                               return;
+                       }
+                       // if the binding declaring class is not visible, need special
+                       // action
+                       // for runtime compatibility on 1.2 VMs : change the declaring class
+                       // of the binding
+                       // NOTE: from target 1.2 on, field's declaring class is touched if
+                       // any different from receiver type
+                       // and not from Object or implicit static field access.
+                       // if (fieldBinding.declaringClass != this.actualReceiverType
+                       // && !this.actualReceiverType.isArrayType()
+                       // && fieldBinding.declaringClass != null
+                       // && fieldBinding.constant == NotAConstant
+                       // && ((currentScope.environment().options.targetJDK >=
+                       // CompilerOptions.JDK1_2
+                       // && !fieldBinding.isStatic()
+                       // && fieldBinding.declaringClass.id != T_Object) // no change for
+                       // Object fields (if there was any)
+                       // || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
+                       // this.codegenBinding =
+                       // currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding,
+                       // (ReferenceBinding)this.actualReceiverType);
+                       // }
+               }
        }
-       return null;
-}
-public TypeBinding resolveType(BlockScope scope) {
-       // for code gen, harm the restrictiveFlag       
 
-       this.actualReceiverType = this.receiverType = scope.enclosingSourceType();
-       
-       if ((this.codegenBinding = this.binding = scope.getBinding(token, bits & RestrictiveFlagMASK, this)).isValidBinding()) {
-               switch (bits & RestrictiveFlagMASK) {
-                       case VARIABLE : // =========only variable============
-                       case VARIABLE | TYPE : //====both variable and type============
+       public TypeBinding reportError(BlockScope scope) {
+               // =====error cases=======
+               constant = Constant.NotAConstant;
+               if (binding instanceof ProblemFieldBinding) {
+                       scope.problemReporter().invalidField(this, (FieldBinding) binding);
+               } else if (binding instanceof ProblemReferenceBinding) {
+                       scope.problemReporter().invalidType(this, (TypeBinding) binding);
+               } else {
+                       scope.problemReporter().unresolvableReference(this, binding);
+               }
+               return null;
+       }
+
+       public TypeBinding resolveType(BlockScope scope) {
+               // for code gen, harm the restrictiveFlag
+
+               this.actualReceiverType = this.receiverType = scope
+                               .enclosingSourceType();
+
+               if ((this.codegenBinding = this.binding = scope.getBinding(token, bits
+                               & RestrictiveFlagMASK, this)).isValidBinding()) {
+                       switch (bits & RestrictiveFlagMASK) {
+                       case VARIABLE: // =========only variable============
+                       case VARIABLE | TYPE: // ====both variable and type============
                                if (binding instanceof VariableBinding) {
                                        VariableBinding variable = (VariableBinding) binding;
                                        if (binding instanceof LocalVariableBinding) {
-                                               bits &= ~RestrictiveFlagMASK;  // clear bits
+                                               bits &= ~RestrictiveFlagMASK; // clear bits
                                                bits |= LOCAL;
                                                if ((this.bits & IsStrictlyAssignedMASK) == 0) {
                                                        constant = variable.constant;
@@ -637,7 +780,10 @@ public TypeBinding resolveType(BlockScope scope) {
                                                        constant = NotAConstant;
                                                }
                                                if ((!variable.isFinal()) && ((bits & DepthMASK) != 0)) {
-                                                       scope.problemReporter().cannotReferToNonFinalOuterLocal((LocalVariableBinding)variable, this);
+                                                       scope.problemReporter()
+                                                                       .cannotReferToNonFinalOuterLocal(
+                                                                                       (LocalVariableBinding) variable,
+                                                                                       this);
                                                }
                                                return this.resolvedType = variable.type;
                                        }
@@ -646,32 +792,39 @@ public TypeBinding resolveType(BlockScope scope) {
                                }
 
                                // thus it was a type
-                               bits &= ~RestrictiveFlagMASK;  // clear bits
+                               bits &= ~RestrictiveFlagMASK; // clear bits
                                bits |= TYPE;
-                       case TYPE : //========only type==============
+                       case TYPE: // ========only type==============
                                constant = Constant.NotAConstant;
-                               //deprecated test
+                               // deprecated test
                                if (isTypeUseDeprecated((TypeBinding) binding, scope))
-                                       scope.problemReporter().deprecatedType((TypeBinding) binding, this);
+                                       scope.problemReporter().deprecatedType(
+                                                       (TypeBinding) binding, this);
                                return this.resolvedType = (TypeBinding) binding;
+                       }
                }
+
+               // error scenarii
+               return this.resolvedType = this.reportError(scope);
        }
 
-       // error scenarii
-       return this.resolvedType = this.reportError(scope);
-}
-public StringBuffer printExpression(int indent, StringBuffer output){
-       
+       public StringBuffer printExpression(int indent, StringBuffer output) {
+
                return output.append(token);
        }
-public String toStringExpression(){
 
-       return new String(token);}
-public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
-       visitor.visit(this, scope);
-       visitor.endVisit(this, scope);
-}
-public String unboundReferenceErrorName(){
+       public String toStringExpression() {
+
+               return new String(token);
+       }
 
-       return new String(token);}
+       public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
+               visitor.visit(this, scope);
+               visitor.endVisit(this, scope);
+       }
+
+       public String unboundReferenceErrorName() {
+
+               return new String(token);
+       }
 }