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

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