net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/SingleNameReference.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  ******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.ast;
  12
  13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
  14 import net.sourceforge.phpdt.internal.compiler.impl.*;
  15 import net.sourceforge.phpdt.internal.compiler.codegen.*;
  16 import net.sourceforge.phpdt.internal.compiler.flow.*;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.*;
  18
  19 public class SingleNameReference extends NameReference implements OperatorIds {
  20         public char[] token;
  21
  22         public MethodBinding[] syntheticAccessors; // [0]=read accessor [1]=write accessor
  23         public static final int READ = 0;
  24         public static final int WRITE = 1;
  25
  26 public SingleNameReference(char[] source, long pos) {
  27         super();
  28         token = source;
  29         sourceStart = (int) (pos >>> 32);
  30         sourceEnd = (int) pos;
  31 }
  32 public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {
  33
  34         // compound assignment extra work
  35         if (isCompound) { // check the variable part is initialized if blank final
  36                 switch (bits & RestrictiveFlagMASK) {
  37                         case FIELD : // reading a field
  38                                 FieldBinding fieldBinding;
  39                                 if ((fieldBinding = (FieldBinding) binding).isFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
  40                                         if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
  41                                                 currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
  42                                                 // we could improve error msg here telling "cannot use compound assignment on final blank field"
  43                                         }
  44                                 }
  45                                 manageSyntheticReadAccessIfNecessary(currentScope);
  46                                 break;
  47                         case LOCAL : // reading a local variable
  48                                 // check if assigning a final blank field
  49                                 LocalVariableBinding localBinding;
  50                                 if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
  51                                         currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
  52                                         // we could improve error msg here telling "cannot use compound assignment on final local variable"
  53                                 }
  54                                 if (!flowInfo.isFakeReachable()) localBinding.used = true;
  55                 }
  56         }
  57         if (assignment.expression != null) {
  58                 flowInfo = assignment.expression.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
  59         }
  60         switch (bits & RestrictiveFlagMASK) {
  61                 case FIELD : // assigning to a field
  62                         manageSyntheticWriteAccessIfNecessary(currentScope);
  63
  64                         // check if assigning a final field
  65                         FieldBinding fieldBinding;
  66                         if ((fieldBinding = (FieldBinding) binding).isFinal()) {
  67                                 // inside a context where allowed
  68                                 if (currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
  69                                         if (flowInfo.isPotentiallyAssigned(fieldBinding)) {
  70                                                 currentScope.problemReporter().duplicateInitializationOfBlankFinalField(fieldBinding, this);
  71                                         }
  72                                         flowInfo.markAsDefinitelyAssigned(fieldBinding);
  73                                         flowContext.recordSettingFinal(fieldBinding, this);
  74                                 } else {
  75                                         currentScope.problemReporter().cannotAssignToFinalField(fieldBinding, this);
  76                                 }
  77                         }
  78                         break;
  79                 case LOCAL : // assigning to a local variable
  80                         LocalVariableBinding localBinding = (LocalVariableBinding) binding;
  81                         if (!flowInfo.isDefinitelyAssigned(localBinding)){// for local variable debug attributes
  82                                 bits |= FirstAssignmentToLocalMASK;
  83                         } else {
  84                                 bits &= ~FirstAssignmentToLocalMASK;
  85                         }
  86                         if (localBinding.isFinal()) {
  87                                 if ((bits & DepthMASK) == 0) {
  88                                         if (flowInfo.isPotentiallyAssigned(localBinding)) {
  89                                                 currentScope.problemReporter().duplicateInitializationOfFinalLocal(localBinding, this);
  90                                         }
  91                                         flowContext.recordSettingFinal(localBinding, this);
  92                                 } else {
  93                                         currentScope.problemReporter().cannotAssignToFinalOuterLocal(localBinding, this);
  94                                 }
  95                         }
  96                         flowInfo.markAsDefinitelyAssigned(localBinding);
  97         }
  98         manageEnclosingInstanceAccessIfNecessary(currentScope);
  99         return flowInfo;
 100 }
 101 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
 102         return analyseCode(currentScope, flowContext, flowInfo, true);
 103 }
 104 public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
 105
 106         switch (bits & RestrictiveFlagMASK) {
 107                 case FIELD : // reading a field
 108                         if (valueRequired) {
 109                                 manageSyntheticReadAccessIfNecessary(currentScope);
 110                         }
 111                         // check if reading a final blank field
 112                         FieldBinding fieldBinding;
 113                         if ((fieldBinding = (FieldBinding) binding).isFinal() && currentScope.allowBlankFinalFieldAssignment(fieldBinding)) {
 114                                 if (!flowInfo.isDefinitelyAssigned(fieldBinding)) {
 115                                         currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
 116                                 }
 117                         }
 118                         break;
 119                 case LOCAL : // reading a local variable
 120                         LocalVariableBinding localBinding;
 121                         if (!flowInfo.isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
 122                                 currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
 123                         }
 124                         if (!flowInfo.isFakeReachable()) localBinding.used = true;
 125         }
 126         if (valueRequired) {
 127                 manageEnclosingInstanceAccessIfNecessary(currentScope);
 128         }
 129         return flowInfo;
 130 }
 131 public TypeBinding checkFieldAccess(BlockScope scope) {
 132
 133         FieldBinding fieldBinding = (FieldBinding) binding;
 134
 135         bits &= ~RestrictiveFlagMASK; // clear bits
 136         bits |= FIELD;
 137         if (!((FieldBinding) binding).isStatic()) {
 138                 // must check for the static status....
 139                 if (scope.methodScope().isStatic) {
 140                         scope.problemReporter().staticFieldAccessToNonStaticVariable(
 141                                 this,
 142                                 fieldBinding);
 143                         constant = NotAConstant;
 144                         return null;
 145                 }
 146         }
 147         constant = FieldReference.getConstantFor(fieldBinding, true, this, scope, 0);
 148         if (isFieldUseDeprecated(fieldBinding, scope))
 149                 scope.problemReporter().deprecatedField(fieldBinding, this);
 150
 151         //===============================================
 152         //cycle are forbidden ONLY within the same class...why ?????? (poor javac....)
 153         //Cycle can be done using cross class ref but not direct into a same class reference ????
 154         //class A {     static int k = B.k+1;}
 155         //class B {     static int k = A.k+2;}
 156         //The k-cycle in this example is valid.
 157
 158         //class C { static int k = k + 1 ;}
 159         //here it is forbidden ! ????
 160         //but the next one is valid !!!
 161         //class C { static int k = C.k + 1;}
 162
 163         //notice that the next one is also valid ?!?!
 164         //class A {     static int k = foo().k+1 ; static A foo(){return new A();}}
 165
 166         //for all these reasons, the next piece of code is only here and not
 167         //commun for all FieldRef and QualifiedNameRef....(i.e. in the getField(..) API.....
 168
 169         //instance field may refer to forward static field, like in
 170         //int i = staticI;
 171         //static int staticI = 2 ;
 172
 173         MethodScope ms = scope.methodScope();
 174         if (ms.enclosingSourceType() == fieldBinding.declaringClass
 175                 && ms.fieldDeclarationIndex != ms.NotInFieldDecl
 176                 && fieldBinding.id >= ms.fieldDeclarationIndex) {
 177                 //if the field is static and ms is not .... then it is valid
 178                 if (!fieldBinding.isStatic() || ms.isStatic)
 179                         scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
 180         }
 181         //====================================================
 182
 183         return fieldBinding.type;
 184
 185 }
 186 public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {
 187
 188         // optimizing assignment like: i = i + 1 or i = 1 + i
 189         if (assignment.expression.isCompactableOperation()) {
 190                 BinaryExpression operation = (BinaryExpression) assignment.expression;
 191                 SingleNameReference variableReference;
 192                 if ((operation.left instanceof SingleNameReference) && ((variableReference = (SingleNameReference) operation.left).binding == binding)) {
 193                         // i = i + value, then use the variable on the right hand side, since it has the correct implicit conversion
 194                         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);
 195                         return;
 196                 }
 197                 int operator = (operation.bits & OperatorMASK) >> OperatorSHIFT;
 198                 if ((operation.right instanceof SingleNameReference)
 199                         && ((operator == PLUS) || (operator == MULTIPLY)) // only commutative operations
 200                         && ((variableReference = (SingleNameReference) operation.right).binding == binding)
 201                         && (operation.left.constant != NotAConstant) // exclude non constant expressions, since could have side-effect
 202                         && ((operation.left.implicitConversion >> 4) != T_String) // exclude string concatenation which would occur backwards
 203                         && ((operation.right.implicitConversion >> 4) != T_String)) { // exclude string concatenation which would occur backwards
 204                         // i = value + i, then use the variable on the right hand side, since it has the correct implicit conversion
 205                         variableReference.generateCompoundAssignment(currentScope, codeStream, syntheticAccessors == null ? null : syntheticAccessors[WRITE], operation.left, operator, operation.right.implicitConversion /*should be equivalent to no conversion*/, valueRequired);
 206                         return;
 207                 }
 208         }
 209         switch (bits & RestrictiveFlagMASK) {
 210                 case FIELD : // assigning to a field
 211                         FieldBinding fieldBinding;
 212                         if (!(fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) { // need a receiver?
 213                                 if ((bits & DepthMASK) != 0) {
 214                                         Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
 215                                         if (emulationPath == null) {
 216                                                 // internal error, per construction we should have found it
 217                                                 currentScope.problemReporter().needImplementation();
 218                                         } else {
 219                                                 codeStream.generateOuterAccess(emulationPath, this, currentScope);
 220                                         }
 221                                 } else {
 222                                         this.generateReceiver(codeStream);
 223                                 }
 224                         }
 225                         assignment.expression.generateCode(currentScope, codeStream, true);
 226                         fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null : syntheticAccessors[WRITE], valueRequired);
 227                         if (valueRequired) {
 228                                 codeStream.generateImplicitConversion(assignment.implicitConversion);
 229                         }
 230                         return;
 231                 case LOCAL : // assigning to a local variable
 232                         LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
 233                         if (localBinding.resolvedPosition != -1) {
 234                                 assignment.expression.generateCode(currentScope, codeStream, true);
 235                         } else {
 236                                 if (assignment.expression.constant != NotAConstant) {
 237                                         // assigning an unused local to a constant value = no actual assignment is necessary
 238                                         if (valueRequired) {
 239                                                 codeStream.generateConstant(assignment.expression.constant, assignment.implicitConversion);
 240                                         }
 241                                 } else {
 242                                         assignment.expression.generateCode(currentScope, codeStream, true);
 243                                         /* Even though the value may not be required, we force it to be produced, and discard it later
 244                                         on if it was actually not necessary, so as to provide the same behavior as JDK1.2beta3. */
 245                                         if (valueRequired) {
 246                                                 codeStream.generateImplicitConversion(assignment.implicitConversion); // implicit conversion
 247                                         } else {
 248                                                 if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
 249                                                         codeStream.pop2();
 250                                                 } else {
 251                                                         codeStream.pop();
 252                                                 }
 253                                         }
 254                                 }
 255                                 return;
 256                         }
 257                         // normal local assignment (since cannot store in outer local which are final locations)
 258                         codeStream.store(localBinding, valueRequired);
 259                         if ((bits & FirstAssignmentToLocalMASK) != 0) { // for local variable debug attributes
 260                                 localBinding.recordInitializationStartPC(codeStream.position);
 261                         }
 262                         // implicit conversion
 263                         if (valueRequired) {
 264                                 codeStream.generateImplicitConversion(assignment.implicitConversion);
 265                         }
 266         }
 267 }
 268 public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
 269         int pc = codeStream.position;
 270         if (constant != NotAConstant) {
 271                 if (valueRequired) {
 272                         codeStream.generateConstant(constant, implicitConversion);
 273                 }
 274         } else {
 275                 switch (bits & RestrictiveFlagMASK) {
 276                         case FIELD : // reading a field
 277                                 FieldBinding fieldBinding;
 278                                 if (valueRequired) {
 279                                         if ((fieldBinding = (FieldBinding) this.codegenBinding).constant == NotAConstant) { // directly use inlined value for constant fields
 280                                                 boolean isStatic;
 281                                                 if (!(isStatic = fieldBinding.isStatic())) {
 282                                                         if ((bits & DepthMASK) != 0) {
 283                                                                 Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
 284                                                                 if (emulationPath == null) {
 285                                                                         // internal error, per construction we should have found it
 286                                                                         currentScope.problemReporter().needImplementation();
 287                                                                 } else {
 288                                                                         codeStream.generateOuterAccess(emulationPath, this, currentScope);
 289                                                                 }
 290                                                         } else {
 291                                                                 generateReceiver(codeStream);
 292                                                         }
 293                                                 }
 294                                                 // managing private access
 295                                                 if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
 296                                                         if (isStatic) {
 297                                                                 codeStream.getstatic(fieldBinding);
 298                                                         } else {
 299                                                                 codeStream.getfield(fieldBinding);
 300                                                         }
 301                                                 } else {
 302                                                         codeStream.invokestatic(syntheticAccessors[READ]);
 303                                                 }
 304                                                 codeStream.generateImplicitConversion(implicitConversion);
 305                                         } else { // directly use the inlined value
 306                                                 codeStream.generateConstant(fieldBinding.constant, implicitConversion);
 307                                         }
 308                                 }
 309                                 break;
 310                         case LOCAL : // reading a local
 311                                 LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
 312                                 if (valueRequired) {
 313                                         // outer local?
 314                                         if ((bits & DepthMASK) != 0) {
 315                                                 // outer local can be reached either through a synthetic arg or a synthetic field
 316                                                 VariableBinding[] path = currentScope.getEmulationPath(localBinding);
 317                                                 if (path == null) {
 318                                                         // emulation was not possible (should not happen per construction)
 319                                                         currentScope.problemReporter().needImplementation();
 320                                                 } else {
 321                                                         codeStream.generateOuterAccess(path, this, currentScope);
 322                                                 }
 323                                         } else {
 324                                                 // regular local variable read
 325                                                 codeStream.load(localBinding);
 326                                         }
 327                                         codeStream.generateImplicitConversion(implicitConversion);
 328                                 }
 329                 }
 330         }
 331         codeStream.recordPositionsFrom(pc, this.sourceStart);
 332 }
 333 /*
 334  * Regular API for compound assignment, relies on the fact that there is only one reference to the
 335  * variable, which carries both synthetic read/write accessors.
 336  * The APIs with an extra argument is used whenever there are two references to the same variable which
 337  * are optimized in one access: e.g "a = a + 1" optimized into "a++".
 338  */
 339 public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
 340
 341         this.generateCompoundAssignment(
 342                 currentScope,
 343                 codeStream,
 344                 syntheticAccessors == null ? null : syntheticAccessors[WRITE],
 345                 expression,
 346                 operator,
 347                 assignmentImplicitConversion,
 348                 valueRequired);
 349 }
 350 /*
 351  * The APIs with an extra argument is used whenever there are two references to the same variable which
 352  * are optimized in one access: e.g "a = a + 1" optimized into "a++".
 353  */
 354 public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, MethodBinding writeAccessor, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
 355         switch (bits & RestrictiveFlagMASK) {
 356                 case FIELD : // assigning to a field
 357                         FieldBinding fieldBinding;
 358                         if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
 359                                 if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
 360                                         codeStream.getstatic(fieldBinding);
 361                                 } else {
 362                                         codeStream.invokestatic(syntheticAccessors[READ]);
 363                                 }
 364                         } else {
 365                                 if ((bits & DepthMASK) != 0) {
 366                                         Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
 367                                         if (emulationPath == null) {
 368                                                 // internal error, per construction we should have found it
 369                                                 currentScope.problemReporter().needImplementation();
 370                                         } else {
 371                                                 codeStream.generateOuterAccess(emulationPath, this, currentScope);
 372                                         }
 373                                 } else {
 374                                         codeStream.aload_0();
 375                                 }
 376                                 codeStream.dup();
 377                                 if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
 378                                         codeStream.getfield(fieldBinding);
 379                                 } else {
 380                                         codeStream.invokestatic(syntheticAccessors[READ]);
 381                                 }
 382                         }
 383                         break;
 384                 case LOCAL : // assigning to a local variable (cannot assign to outer local)
 385                         LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
 386                         Constant assignConstant;
 387                         int increment;
 388                         // using incr bytecode if possible
 389                         switch (localBinding.type.id) {
 390                                 case T_String :
 391                                         codeStream.generateStringAppend(currentScope, this, expression);
 392                                         if (valueRequired) {
 393                                                 codeStream.dup();
 394                                         }
 395                                         codeStream.store(localBinding, false);
 396                                         return;
 397                                 case T_int :
 398                                         if (((assignConstant = expression.constant) != NotAConstant)
 399                                                 && (assignConstant.typeID() != T_float) // only for integral types
 400                                                 && (assignConstant.typeID() != T_double)
 401                                                 && ((increment = assignConstant.intValue()) == (short) increment)) { // 16 bits value
 402                                                 switch (operator) {
 403                                                         case PLUS :
 404                                                                 codeStream.iinc(localBinding.resolvedPosition, increment);
 405                                                                 if (valueRequired) {
 406                                                                         codeStream.load(localBinding);
 407                                                                 }
 408                                                                 return;
 409                                                         case MINUS :
 410                                                                 codeStream.iinc(localBinding.resolvedPosition, -increment);
 411                                                                 if (valueRequired) {
 412                                                                         codeStream.load(localBinding);
 413                                                                 }
 414                                                                 return;
 415                                                 }
 416                                         }
 417                                 default :
 418                                         codeStream.load(localBinding);
 419                         }
 420         }
 421         // perform the actual compound operation
 422         int operationTypeID;
 423         if ((operationTypeID = implicitConversion >> 4) == T_String || operationTypeID == T_Object) {
 424                 // we enter here if the single name reference is a field of type java.lang.String or if the type of the
 425                 // operation is java.lang.Object
 426                 // For example: o = o + ""; // where the compiled type of o is java.lang.Object.
 427                 codeStream.generateStringAppend(currentScope, null, expression);
 428         } else {
 429                 // promote the array reference to the suitable operation type
 430                 codeStream.generateImplicitConversion(implicitConversion);
 431                 // generate the increment value (will by itself  be promoted to the operation value)
 432                 if (expression == IntLiteral.One){ // prefix operation
 433                         codeStream.generateConstant(expression.constant, implicitConversion);
 434                 } else {
 435                         expression.generateCode(currentScope, codeStream, true);
 436                 }
 437                 // perform the operation
 438                 codeStream.sendOperator(operator, operationTypeID);
 439                 // cast the value back to the array reference type
 440                 codeStream.generateImplicitConversion(assignmentImplicitConversion);
 441         }
 442         // store the result back into the variable
 443         switch (bits & RestrictiveFlagMASK) {
 444                 case FIELD : // assigning to a field
 445                         fieldStore(codeStream, (FieldBinding) this.codegenBinding, writeAccessor, valueRequired);
 446                         return;
 447                 case LOCAL : // assigning to a local variable
 448                         LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
 449                         if (valueRequired) {
 450                                 if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
 451                                         codeStream.dup2();
 452                                 } else {
 453                                         codeStream.dup();
 454                                 }
 455                         }
 456                         codeStream.store(localBinding, false);
 457         }
 458 }
 459 public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
 460         switch (bits & RestrictiveFlagMASK) {
 461                 case FIELD : // assigning to a field
 462                         FieldBinding fieldBinding;
 463                         if ((fieldBinding = (FieldBinding) this.codegenBinding).isStatic()) {
 464                                 if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
 465                                         codeStream.getstatic(fieldBinding);
 466                                 } else {
 467                                         codeStream.invokestatic(syntheticAccessors[READ]);
 468                                 }
 469                         } else {
 470                                 if ((bits & DepthMASK) != 0) {
 471                                         Object[] emulationPath = currentScope.getExactEmulationPath(currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT));
 472                                         if (emulationPath == null) {
 473                                                 // internal error, per construction we should have found it
 474                                                 currentScope.problemReporter().needImplementation();
 475                                         } else {
 476                                                 codeStream.generateOuterAccess(emulationPath, this, currentScope);
 477                                         }
 478                                 } else {
 479                                         codeStream.aload_0();
 480                                 }
 481                                 codeStream.dup();
 482                                 if ((syntheticAccessors == null) || (syntheticAccessors[READ] == null)) {
 483                                         codeStream.getfield(fieldBinding);
 484                                 } else {
 485                                         codeStream.invokestatic(syntheticAccessors[READ]);
 486                                 }
 487                         }
 488                         if (valueRequired) {
 489                                 if (fieldBinding.isStatic()) {
 490                                         if ((fieldBinding.type == LongBinding) || (fieldBinding.type == DoubleBinding)) {
 491                                                 codeStream.dup2();
 492                                         } else {
 493                                                 codeStream.dup();
 494                                         }
 495                                 } else { // Stack:  [owner][old field value]  ---> [old field value][owner][old field value]
 496                                         if ((fieldBinding.type == LongBinding) || (fieldBinding.type == DoubleBinding)) {
 497                                                 codeStream.dup2_x1();
 498                                         } else {
 499                                                 codeStream.dup_x1();
 500                                         }
 501                                 }
 502                         }
 503                         codeStream.generateConstant(postIncrement.expression.constant, implicitConversion);
 504                         codeStream.sendOperator(postIncrement.operator, fieldBinding.type.id);
 505                         codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
 506                         fieldStore(codeStream, fieldBinding, syntheticAccessors == null ? null : syntheticAccessors[WRITE], false);
 507                         return;
 508                 case LOCAL : // assigning to a local variable
 509                         LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
 510                         // using incr bytecode if possible
 511                         if (localBinding.type == IntBinding) {
 512                                 if (valueRequired) {
 513                                         codeStream.load(localBinding);
 514                                 }
 515                                 if (postIncrement.operator == PLUS) {
 516                                         codeStream.iinc(localBinding.resolvedPosition, 1);
 517                                 } else {
 518                                         codeStream.iinc(localBinding.resolvedPosition, -1);
 519                                 }
 520                         } else {
 521                                 codeStream.load(localBinding);
 522                                 if (valueRequired){
 523                                         if ((localBinding.type == LongBinding) || (localBinding.type == DoubleBinding)) {
 524                                                 codeStream.dup2();
 525                                         } else {
 526                                                 codeStream.dup();
 527                                         }
 528                                 }
 529                                 codeStream.generateConstant(postIncrement.expression.constant, implicitConversion);
 530                                 codeStream.sendOperator(postIncrement.operator, localBinding.type.id);
 531                                 codeStream.generateImplicitConversion(postIncrement.assignmentImplicitConversion);
 532
 533                                 codeStream.store(localBinding, false);
 534                         }
 535         }
 536 }
 537 public void generateReceiver(CodeStream codeStream) {
 538         codeStream.aload_0();
 539 }
 540 public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {
 541
 542         //If inlinable field, forget the access emulation, the code gen will directly target it
 543         if (((bits & DepthMASK) == 0) || (constant != NotAConstant)) return;
 544
 545         switch (bits & RestrictiveFlagMASK) {
 546                 case FIELD :
 547                         FieldBinding fieldBinding;
 548                         if ((fieldBinding = (FieldBinding)binding).isStatic() || (fieldBinding.constant != NotAConstant)) return;
 549                         ReferenceBinding compatibleType = currentScope.enclosingSourceType();
 550                         // the declaringClass of the target binding must be compatible with the enclosing
 551                         // type at <depth> levels outside
 552                         for (int i = 0, depth = (bits & DepthMASK) >> DepthSHIFT; i < depth; i++) {
 553                                 compatibleType = compatibleType.enclosingType();
 554                         }
 555                         currentScope.emulateOuterAccess(compatibleType, false); // request cascade of accesses
 556                         break;
 557                 case LOCAL :
 558                         currentScope.emulateOuterAccess((LocalVariableBinding) binding);
 559         }
 560 }
 561 public void manageSyntheticReadAccessIfNecessary(BlockScope currentScope) {
 562
 563         //If inlinable field, forget the access emulation, the code gen will directly target it
 564         if (constant != NotAConstant)
 565                 return;
 566
 567         if ((bits & FIELD) != 0) {
 568                 FieldBinding fieldBinding = (FieldBinding) binding;
 569                 if (((bits & DepthMASK) != 0)
 570                         && (fieldBinding.isPrivate() // private access
 571                                 || (fieldBinding.isProtected() // implicit protected access
 572                                                 && fieldBinding.declaringClass.getPackage()
 573                                                         != currentScope.enclosingSourceType().getPackage()))) {
 574                         if (syntheticAccessors == null)
 575                                 syntheticAccessors = new MethodBinding[2];
 576                         syntheticAccessors[READ] =
 577                                 ((SourceTypeBinding)currentScope.enclosingSourceType().
 578                                         enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT)).
 579                                                 addSyntheticMethod(fieldBinding, true);
 580                         currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
 581                         return;
 582                 }
 583                 // if the binding declaring class is not visible, need special action
 584                 // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
 585                 // NOTE: from 1.4 on, field's declaring class is touched if any different from receiver type
 586                 // and not from Object or implicit static field access.
 587                 if (fieldBinding.declaringClass != this.actualReceiverType
 588                         && !this.actualReceiverType.isArrayType()
 589                         && fieldBinding.declaringClass != null
 590                         && fieldBinding.constant == NotAConstant
 591                         && ((currentScope.environment().options.complianceLevel >= CompilerOptions.JDK1_4
 592                                         && !fieldBinding.isStatic()
 593                                         && fieldBinding.declaringClass.id != T_Object) // no change for Object fields (if there was any)
 594                                 || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
 595                         this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)this.actualReceiverType);
 596                 }
 597         }
 598 }
 599 public void manageSyntheticWriteAccessIfNecessary(BlockScope currentScope) {
 600
 601         if ((bits & FIELD) != 0) {
 602                 FieldBinding fieldBinding = (FieldBinding) binding;
 603                 if (((bits & DepthMASK) != 0)
 604                         && (fieldBinding.isPrivate() // private access
 605                                 || (fieldBinding.isProtected() // implicit protected access
 606                                                 && fieldBinding.declaringClass.getPackage()
 607                                                         != currentScope.enclosingSourceType().getPackage()))) {
 608                         if (syntheticAccessors == null)
 609                                 syntheticAccessors = new MethodBinding[2];
 610                         syntheticAccessors[WRITE] =
 611                                 ((SourceTypeBinding)currentScope.enclosingSourceType().
 612                                         enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT)).
 613                                                 addSyntheticMethod(fieldBinding, false);
 614                         currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
 615                         return;
 616                 }
 617                 // if the binding declaring class is not visible, need special action
 618                 // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
 619                 // NOTE: from 1.4 on, field's declaring class is touched if any different from receiver type
 620                 // and not from Object or implicit static field access.
 621                 if (fieldBinding.declaringClass != this.actualReceiverType
 622                         && !this.actualReceiverType.isArrayType()
 623                         && fieldBinding.declaringClass != null
 624                         && fieldBinding.constant == NotAConstant
 625                         && ((currentScope.environment().options.complianceLevel >= CompilerOptions.JDK1_4
 626                                         && !fieldBinding.isStatic()
 627                                         && fieldBinding.declaringClass.id != T_Object) // no change for Object fields (if there was any)
 628                                 || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
 629                         this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)this.actualReceiverType);
 630                 }
 631         }
 632 }
 633 public TypeBinding reportError(BlockScope scope) {
 634         //=====error cases=======
 635         constant = Constant.NotAConstant;
 636         if (binding instanceof ProblemFieldBinding) {
 637                 scope.problemReporter().invalidField(this, (FieldBinding) binding);
 638         } else if (binding instanceof ProblemReferenceBinding) {
 639                 scope.problemReporter().invalidType(this, (TypeBinding) binding);
 640         } else {
 641                 scope.problemReporter().unresolvableReference(this, binding);
 642         }
 643         return null;
 644 }
 645 public TypeBinding resolveType(BlockScope scope) {
 646         // for code gen, harm the restrictiveFlag
 647
 648         this.actualReceiverType = this.receiverType = scope.enclosingSourceType();
 649
 650         if ((this.codegenBinding = this.binding = scope.getBinding(token, bits & RestrictiveFlagMASK, this)).isValidBinding()) {
 651                 switch (bits & RestrictiveFlagMASK) {
 652                         case VARIABLE : // =========only variable============
 653                         case VARIABLE | TYPE : //====both variable and type============
 654                                 if (binding instanceof VariableBinding) {
 655                                         VariableBinding vb = (VariableBinding) binding;
 656                                         if (binding instanceof LocalVariableBinding) {
 657                                                 bits &= ~RestrictiveFlagMASK;  // clear bits
 658                                                 bits |= LOCAL;
 659                                                 constant = vb.constant;
 660                                                 if ((!vb.isFinal()) && ((bits & DepthMASK) != 0))
 661                                                         scope.problemReporter().cannotReferToNonFinalOuterLocal((LocalVariableBinding)vb, this);
 662                                                 return vb.type;
 663                                         }
 664                                         // a field
 665                                         return checkFieldAccess(scope);
 666                                 }
 667
 668                                 // thus it was a type
 669                                 bits &= ~RestrictiveFlagMASK;  // clear bits
 670                                 bits |= TYPE;
 671                         case TYPE : //========only type==============
 672                                 constant = Constant.NotAConstant;
 673                                 //deprecated test
 674                                 if (isTypeUseDeprecated((TypeBinding) binding, scope))
 675                                         scope.problemReporter().deprecatedType((TypeBinding) binding, this);
 676                                 return (TypeBinding) binding;
 677                 }
 678         }
 679
 680         // error scenarii
 681         return this.reportError(scope);
 682 }
 683 public String toStringExpression(){
 684
 685         return new String(token);}
 686 public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
 687         visitor.visit(this, scope);
 688         visitor.endVisit(this, scope);
 689 }
 690 public String unboundReferenceErrorName(){
 691
 692         return new String(token);}
 693 }