net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/internal/compiler/ast/QualifiedNameReference.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.phpeclipse.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.MethodScope;
  21 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemFieldBinding;
  22 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReferenceBinding;
  23 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
  24 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
  25 import net.sourceforge.phpdt.internal.compiler.lookup.SyntheticAccessMethodBinding;
  26 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  27 import net.sourceforge.phpdt.internal.compiler.lookup.VariableBinding;
  28
  29
  30 public class QualifiedNameReference extends NameReference {
  31
  32         public char[][] tokens;
  33         public FieldBinding[] otherBindings, otherCodegenBindings;
  34         int[] otherDepths;
  35         public int indexOfFirstFieldBinding;//points (into tokens) for the first token that corresponds to first FieldBinding
  36         SyntheticAccessMethodBinding syntheticWriteAccessor;
  37         SyntheticAccessMethodBinding[] syntheticReadAccessors;
  38         protected FieldBinding lastFieldBinding;
  39         public QualifiedNameReference(
  40                 char[][] sources,
  41                 int sourceStart,
  42                 int sourceEnd) {
  43                 super();
  44                 tokens = sources;
  45                 this.sourceStart = sourceStart;
  46                 this.sourceEnd = sourceEnd;
  47         }
  48         public FlowInfo analyseAssignment(
  49                 BlockScope currentScope,
  50                 FlowContext flowContext,
  51                 FlowInfo flowInfo,
  52                 Assignment assignment,
  53                 boolean isCompound) {
  54
  55                 // determine the rank until which we now we do not need any actual value for the field access
  56                 int otherBindingsCount = otherBindings == null ? 0 : otherBindings.length;
  57                 boolean needValue = otherBindingsCount == 0 || !this.otherBindings[0].isStatic();
  58                 switch (bits & RestrictiveFlagMASK) {
  59                         case FIELD : // reading a field
  60                                 lastFieldBinding = (FieldBinding) binding;
  61                                 if (needValue) {
  62                                         manageSyntheticReadAccessIfNecessary(currentScope, lastFieldBinding, this.actualReceiverType, 0);
  63                                 }                               // check if final blank field
  64                                 if (lastFieldBinding.isBlankFinal()
  65                                     && this.otherBindings != null // the last field binding is only assigned
  66                                         && currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)) {
  67                                         if (!flowInfo.isDefinitelyAssigned(lastFieldBinding)) {
  68                                                 currentScope.problemReporter().uninitializedBlankFinalField(
  69                                                         lastFieldBinding,
  70                                                         this);
  71                                         }
  72                                 }
  73                                 break;
  74                         case LOCAL :
  75                                 // first binding is a local variable
  76                                 LocalVariableBinding localBinding;
  77                                 if (!flowInfo
  78                                         .isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
  79                                         currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
  80                                 }
  81                                 if (flowInfo.isReachable()) {
  82                                         localBinding.useFlag = LocalVariableBinding.USED;
  83                                 } else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
  84                                         localBinding.useFlag = LocalVariableBinding.FAKE_USED;
  85                                 }
  86                 }
  87
  88                 if (needValue) {
  89                         manageEnclosingInstanceAccessIfNecessary(currentScope);
  90                         // only for first binding
  91                 }
  92                 // all intermediate field accesses are read accesses
  93                 if (otherBindings != null) {
  94                         for (int i = 0; i < otherBindingsCount-1; i++) {
  95                                 lastFieldBinding = otherBindings[i];
  96                                 needValue = !otherBindings[i+1].isStatic();
  97                                 if (needValue) {
  98                                         manageSyntheticReadAccessIfNecessary(
  99                                                 currentScope,
 100                                                 lastFieldBinding,
 101                                                 i == 0
 102                                                         ? ((VariableBinding)binding).type
 103                                                         : otherBindings[i-1].type,
 104                                                 i + 1);
 105                                 }
 106                         }
 107                         lastFieldBinding = otherBindings[otherBindingsCount-1];
 108                 }
 109
 110                 if (isCompound) {
 111                         if (binding == lastFieldBinding
 112                                 && lastFieldBinding.isBlankFinal()
 113                                 && currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)
 114                                 && (!flowInfo.isDefinitelyAssigned(lastFieldBinding))) {
 115                                 currentScope.problemReporter().uninitializedBlankFinalField(
 116                                         lastFieldBinding,
 117                                         this);
 118                         }
 119                         TypeBinding lastReceiverType;
 120                         if (lastFieldBinding == binding){
 121                                 lastReceiverType = this.actualReceiverType;
 122                         } else if (otherBindingsCount == 1){
 123                                 lastReceiverType = ((VariableBinding)this.binding).type;
 124                         } else {
 125                                 lastReceiverType = this.otherBindings[otherBindingsCount-2].type;
 126                         }
 127                         manageSyntheticReadAccessIfNecessary(
 128                                 currentScope,
 129                                 lastFieldBinding,
 130                                 lastReceiverType,
 131                                 lastFieldBinding == binding
 132                                         ? 0
 133                                         : otherBindingsCount);
 134                 }
 135
 136                 if (assignment.expression != null) {
 137                         flowInfo =
 138                                 assignment
 139                                         .expression
 140                                         .analyseCode(currentScope, flowContext, flowInfo)
 141                                         .unconditionalInits();
 142                 }
 143
 144                 // the last field access is a write access
 145                 if (lastFieldBinding.isFinal()) {
 146                         // in a context where it can be assigned?
 147                         if (lastFieldBinding.isBlankFinal()
 148                                         && !isCompound
 149                                         && currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)
 150                                         && indexOfFirstFieldBinding == 1) {
 151                                 if (flowInfo.isPotentiallyAssigned(lastFieldBinding)) {
 152                                         currentScope.problemReporter().duplicateInitializationOfBlankFinalField(lastFieldBinding, this);
 153                                 } else {
 154                                         flowContext.recordSettingFinal(lastFieldBinding, this);
 155                                 }
 156                                 flowInfo.markAsDefinitelyAssigned(lastFieldBinding);
 157                         } else {
 158                                 currentScope.problemReporter().cannotAssignToFinalField(lastFieldBinding, this);
 159                                 if (currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)) { // pretend it got assigned
 160                                         flowInfo.markAsDefinitelyAssigned(lastFieldBinding);
 161                                 }
 162                         }
 163                 }
 164                 // equivalent to valuesRequired[maxOtherBindings]
 165                 TypeBinding lastReceiverType;
 166                 if (lastFieldBinding == binding){
 167                         lastReceiverType = this.actualReceiverType;
 168                 } else if (otherBindingsCount == 1){
 169                         lastReceiverType = ((VariableBinding)this.binding).type;
 170                 } else {
 171                         lastReceiverType = this.otherBindings[otherBindingsCount-2].type;
 172                 }
 173                 manageSyntheticWriteAccessIfNecessary(currentScope, lastFieldBinding, lastReceiverType);
 174
 175                 return flowInfo;
 176         }
 177
 178         public FlowInfo analyseCode(
 179                 BlockScope currentScope,
 180                 FlowContext flowContext,
 181                 FlowInfo flowInfo) {
 182
 183                 return analyseCode(currentScope, flowContext, flowInfo, true);
 184         }
 185
 186         public FlowInfo analyseCode(
 187                 BlockScope currentScope,
 188                 FlowContext flowContext,
 189                 FlowInfo flowInfo,
 190                 boolean valueRequired) {
 191
 192                 // determine the rank until which we now we do not need any actual value for the field access
 193                 int otherBindingsCount = otherBindings == null ? 0 : otherBindings.length;
 194
 195                 boolean needValue = otherBindingsCount == 0 ? valueRequired : !this.otherBindings[0].isStatic();
 196                 switch (bits & RestrictiveFlagMASK) {
 197                         case FIELD : // reading a field
 198                                 if (needValue) {
 199                                         manageSyntheticReadAccessIfNecessary(currentScope, (FieldBinding) binding, this.actualReceiverType, 0);
 200                                 }
 201                                 // check if reading a final blank field
 202                                 FieldBinding fieldBinding;
 203                                         if ((fieldBinding = (FieldBinding) binding).isBlankFinal()
 204                                                 && (indexOfFirstFieldBinding == 1)
 205                                         // was an implicit reference to the first field binding
 206                                                 && currentScope.allowBlankFinalFieldAssignment(fieldBinding)
 207                                                 && (!flowInfo.isDefinitelyAssigned(fieldBinding))) {
 208                                         currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
 209                                 }
 210                                 break;
 211                         case LOCAL : // reading a local variable
 212                                 LocalVariableBinding localBinding;
 213                                 if (!flowInfo
 214                                         .isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
 215                                         currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
 216                                 }
 217                                 if (flowInfo.isReachable()) {
 218                                         localBinding.useFlag = LocalVariableBinding.USED;
 219                                 } else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
 220                                         localBinding.useFlag = LocalVariableBinding.FAKE_USED;
 221                                 }
 222                 }
 223                 if (needValue) {
 224                         manageEnclosingInstanceAccessIfNecessary(currentScope);
 225                         // only for first binding
 226                 }
 227                 if (otherBindings != null) {
 228                         for (int i = 0; i < otherBindingsCount; i++) {
 229                                 needValue = i < otherBindingsCount-1 ? !otherBindings[i+1].isStatic() : valueRequired;
 230                                 if (needValue) {
 231                                         manageSyntheticReadAccessIfNecessary(
 232                                                 currentScope,
 233                                                 otherBindings[i],
 234                                                 i == 0
 235                                                         ? ((VariableBinding)binding).type
 236                                                         : otherBindings[i-1].type,
 237                                                 i + 1);
 238                                 }
 239                         }
 240                 }
 241                 return flowInfo;
 242         }
 243         /**
 244          * Check and/or redirect the field access to the delegate receiver if any
 245          */
 246         public TypeBinding checkFieldAccess(BlockScope scope) {
 247                 // check for forward references
 248                 FieldBinding fieldBinding = (FieldBinding) binding;
 249                 MethodScope methodScope = scope.methodScope();
 250                 if (methodScope.enclosingSourceType() == fieldBinding.declaringClass
 251                         && methodScope.fieldDeclarationIndex != MethodScope.NotInFieldDecl
 252                         && fieldBinding.id >= methodScope.fieldDeclarationIndex) {
 253                         if ((!fieldBinding.isStatic() || methodScope.isStatic)
 254                                 && this.indexOfFirstFieldBinding == 1)
 255                                 scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
 256                 }
 257                 bits &= ~RestrictiveFlagMASK; // clear bits
 258                 bits |= FIELD;
 259                 return getOtherFieldBindings(scope);
 260         }
 261 //      public void generateAssignment(
 262 //              BlockScope currentScope,
 263 //              CodeStream codeStream,
 264 //              Assignment assignment,
 265 //              boolean valueRequired) {
 266 //
 267 //              generateReadSequence(currentScope, codeStream);
 268 //              assignment.expression.generateCode(currentScope, codeStream, true);
 269 //              fieldStore(codeStream, lastFieldBinding, syntheticWriteAccessor, valueRequired);
 270 //              // equivalent to valuesRequired[maxOtherBindings]
 271 //              if (valueRequired) {
 272 //                      codeStream.generateImplicitConversion(assignment.implicitConversion);
 273 //              }
 274 //      }
 275 //      public void generateCode(
 276 //              BlockScope currentScope,
 277 //              CodeStream codeStream,
 278 //              boolean valueRequired) {
 279 //
 280 //              int pc = codeStream.position;
 281 //              if (constant != NotAConstant) {
 282 //                      if (valueRequired) {
 283 //                              codeStream.generateConstant(constant, implicitConversion);
 284 //                      }
 285 //              } else {
 286 //                      generateReadSequence(currentScope, codeStream);
 287 //                      if (valueRequired) {
 288 //                              if (lastFieldBinding.declaringClass == null) { // array length
 289 //                                      codeStream.arraylength();
 290 //                                      codeStream.generateImplicitConversion(implicitConversion);
 291 //                              } else {
 292 //                                      if (lastFieldBinding.constant != NotAConstant) {
 293 //                                              if (!lastFieldBinding.isStatic()){
 294 //                                                      codeStream.invokeObjectGetClass();
 295 //                                                      codeStream.pop();
 296 //                                              }
 297 //                                              // inline the last field constant
 298 //                                              codeStream.generateConstant(lastFieldBinding.constant, implicitConversion);
 299 //                                      } else {
 300 //                                              SyntheticAccessMethodBinding accessor =
 301 //                                                      syntheticReadAccessors == null
 302 //                                                              ? null
 303 //                                                              : syntheticReadAccessors[syntheticReadAccessors.length - 1];
 304 //                                              if (accessor == null) {
 305 //                                                      if (lastFieldBinding.isStatic()) {
 306 //                                                              codeStream.getstatic(lastFieldBinding);
 307 //                                                      } else {
 308 //                                                              codeStream.getfield(lastFieldBinding);
 309 //                                                      }
 310 //                                              } else {
 311 //                                                      codeStream.invokestatic(accessor);
 312 //                                              }
 313 //                                              codeStream.generateImplicitConversion(implicitConversion);
 314 //                                      }
 315 //                              }
 316 //                      } else {
 317 //                              if (lastFieldBinding != null && !lastFieldBinding.isStatic()){
 318 //                                      codeStream.invokeObjectGetClass(); // perform null check
 319 //                                      codeStream.pop();
 320 //                              }
 321 //
 322 //                      }
 323 //              }
 324 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
 325 //      }
 326 //      public void generateCompoundAssignment(
 327 //              BlockScope currentScope,
 328 //              CodeStream codeStream,
 329 //              Expression expression,
 330 //              int operator,
 331 //              int assignmentImplicitConversion,
 332 //              boolean valueRequired) {
 333 //
 334 //              generateReadSequence(currentScope, codeStream);
 335 //              SyntheticAccessMethodBinding accessor =
 336 //                      syntheticReadAccessors == null
 337 //                              ? null
 338 //                              : syntheticReadAccessors[syntheticReadAccessors.length - 1];
 339 //              if (lastFieldBinding.isStatic()) {
 340 //                      if (accessor == null) {
 341 //                              codeStream.getstatic(lastFieldBinding);
 342 //                      } else {
 343 //                              codeStream.invokestatic(accessor);
 344 //                      }
 345 //              } else {
 346 //                      codeStream.dup();
 347 //                      if (accessor == null) {
 348 //                              codeStream.getfield(lastFieldBinding);
 349 //                      } else {
 350 //                              codeStream.invokestatic(accessor);
 351 //                      }
 352 //              }
 353 //              // the last field access is a write access
 354 //              // perform the actual compound operation
 355 //              int operationTypeID;
 356 //              if ((operationTypeID = implicitConversion >> 4) == T_String) {
 357 //                      codeStream.generateStringAppend(currentScope, null, expression);
 358 //              } else {
 359 //                      // promote the array reference to the suitable operation type
 360 //                      codeStream.generateImplicitConversion(implicitConversion);
 361 //                      // generate the increment value (will by itself  be promoted to the operation value)
 362 //                      if (expression == IntLiteral.One) { // prefix operation
 363 //                              codeStream.generateConstant(expression.constant, implicitConversion);
 364 //                      } else {
 365 //                              expression.generateCode(currentScope, codeStream, true);
 366 //                      }
 367 //                      // perform the operation
 368 //                      codeStream.sendOperator(operator, operationTypeID);
 369 //                      // cast the value back to the array reference type
 370 //                      codeStream.generateImplicitConversion(assignmentImplicitConversion);
 371 //              }
 372 //              // actual assignment
 373 //              fieldStore(codeStream, lastFieldBinding, syntheticWriteAccessor, valueRequired);
 374 //              // equivalent to valuesRequired[maxOtherBindings]
 375 //      }
 376 //      public void generatePostIncrement(
 377 //              BlockScope currentScope,
 378 //              CodeStream codeStream,
 379 //              CompoundAssignment postIncrement,
 380 //              boolean valueRequired) {
 381 //              generateReadSequence(currentScope, codeStream);
 382 //              SyntheticAccessMethodBinding accessor =
 383 //                      syntheticReadAccessors == null
 384 //                              ? null
 385 //                              : syntheticReadAccessors[syntheticReadAccessors.length - 1];
 386 //              if (lastFieldBinding.isStatic()) {
 387 //                      if (accessor == null) {
 388 //                              codeStream.getstatic(lastFieldBinding);
 389 //                      } else {
 390 //                              codeStream.invokestatic(accessor);
 391 //                      }
 392 //              } else {
 393 //                      codeStream.dup();
 394 //                      if (accessor == null) {
 395 //                              codeStream.getfield(lastFieldBinding);
 396 //                      } else {
 397 //                              codeStream.invokestatic(accessor);
 398 //                      }
 399 //              }
 400 //              // duplicate the old field value
 401 //              if (valueRequired) {
 402 //                      if (lastFieldBinding.isStatic()) {
 403 //                              if ((lastFieldBinding.type == LongBinding)
 404 //                                      || (lastFieldBinding.type == DoubleBinding)) {
 405 //                                      codeStream.dup2();
 406 //                              } else {
 407 //                                      codeStream.dup();
 408 //                              }
 409 //                      } else { // Stack:  [owner][old field value]  ---> [old field value][owner][old field value]
 410 //                              if ((lastFieldBinding.type == LongBinding)
 411 //                                      || (lastFieldBinding.type == DoubleBinding)) {
 412 //                                      codeStream.dup2_x1();
 413 //                              } else {
 414 //                                      codeStream.dup_x1();
 415 //                              }
 416 //                      }
 417 //              }
 418 //              codeStream.generateConstant(
 419 //                      postIncrement.expression.constant,
 420 //                      implicitConversion);
 421 //              codeStream.sendOperator(postIncrement.operator, lastFieldBinding.type.id);
 422 //              codeStream.generateImplicitConversion(
 423 //                      postIncrement.assignmentImplicitConversion);
 424 //              fieldStore(codeStream, lastFieldBinding, syntheticWriteAccessor, false);
 425 //      }
 426 //      /*
 427 //       * Generate code for all bindings (local and fields) excluding the last one, which may then be generated code
 428 //       * for a read or write access.
 429 //       */
 430 //      public void generateReadSequence(
 431 //              BlockScope currentScope,
 432 //              CodeStream codeStream) {
 433 //
 434 //              // determine the rank until which we now we do not need any actual value for the field access
 435 //              int otherBindingsCount = this.otherCodegenBindings == null ? 0 : otherCodegenBindings.length;
 436 //
 437 //              boolean needValue = otherBindingsCount == 0 || !this.otherBindings[0].isStatic();
 438 //              switch (bits & RestrictiveFlagMASK) {
 439 //                      case FIELD :
 440 //                              lastFieldBinding = (FieldBinding) this.codegenBinding;
 441 //                              // if first field is actually constant, we can inline it
 442 //                              if (lastFieldBinding.constant != NotAConstant) {
 443 //                                      break;
 444 //                              }
 445 //                              if (needValue && !lastFieldBinding.isStatic()) {
 446 //                                      if ((bits & DepthMASK) != 0) {
 447 //                                              ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
 448 //                                              Object[] emulationPath = currentScope.getEmulationPath(targetType, true /*only exact match*/, false/*consider enclosing arg*/);
 449 //                                              codeStream.generateOuterAccess(emulationPath, this, targetType, currentScope);
 450 //                                      } else {
 451 //                                              generateReceiver(codeStream);
 452 //                                      }
 453 //                              }
 454 //                              break;
 455 //                      case LOCAL : // reading the first local variable
 456 //                              if (!needValue) break; // no value needed
 457 //                              lastFieldBinding = null;
 458 //                              LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
 459 //                              // regular local variable read
 460 //                              if (localBinding.constant != NotAConstant) {
 461 //                                      codeStream.generateConstant(localBinding.constant, 0);
 462 //                                      // no implicit conversion
 463 //                              } else {
 464 //                                      // outer local?
 465 //                                      if ((bits & DepthMASK) != 0) {
 466 //                                              // outer local can be reached either through a synthetic arg or a synthetic field
 467 //                                              VariableBinding[] path = currentScope.getEmulationPath(localBinding);
 468 //                                              codeStream.generateOuterAccess(path, this, localBinding, currentScope);
 469 //                                      } else {
 470 //                                              codeStream.load(localBinding);
 471 //                                      }
 472 //                              }
 473 //              }
 474 //
 475 //              // all intermediate field accesses are read accesses
 476 //              // only the last field binding is a write access
 477 //              if (this.otherCodegenBindings != null) {
 478 //                      for (int i = 0; i < otherBindingsCount; i++) {
 479 //                              FieldBinding nextField = this.otherCodegenBindings[i];
 480 //                              if (lastFieldBinding != null) {
 481 //                                      needValue = !nextField.isStatic();
 482 //                                      if (needValue) {
 483 //                                              MethodBinding accessor =
 484 //                                                      syntheticReadAccessors == null ? null : syntheticReadAccessors[i];
 485 //                                              if (accessor == null) {
 486 //                                                      if (lastFieldBinding.constant != NotAConstant) {
 487 //                                                              if (this.lastFieldBinding != this.codegenBinding && !this.lastFieldBinding.isStatic()) {
 488 //                                                                      codeStream.invokeObjectGetClass(); // perform null check
 489 //                                                                      codeStream.pop();
 490 //                                                              }
 491 //                                                              codeStream.generateConstant(lastFieldBinding.constant, 0);
 492 //                                                      } else if (lastFieldBinding.isStatic()) {
 493 //                                                              codeStream.getstatic(lastFieldBinding);
 494 //                                                      } else {
 495 //                                                              codeStream.getfield(lastFieldBinding);
 496 //                                                      }
 497 //                                              } else {
 498 //                                                      codeStream.invokestatic(accessor);
 499 //                                              }
 500 //                                      } else {
 501 //                                              if (this.codegenBinding != this.lastFieldBinding && !this.lastFieldBinding.isStatic()){
 502 //                                                      codeStream.invokeObjectGetClass(); // perform null check
 503 //                                                      codeStream.pop();
 504 //                                              }
 505 //                                      }
 506 //                              }
 507 //                              this.lastFieldBinding = nextField;
 508 //                      }
 509 //              }
 510 //      }
 511 //      public void generateReceiver(CodeStream codeStream) {
 512 //              codeStream.aload_0();
 513 //      }
 514         public TypeBinding getOtherFieldBindings(BlockScope scope) {
 515                 // At this point restrictiveFlag may ONLY have two potential value : FIELD LOCAL (i.e cast <<(VariableBinding) binding>> is valid)
 516                 if ((bits & FIELD) != 0) {
 517                         if (!((FieldBinding) binding).isStatic()) {
 518                                 //must check for the static status....
 519                                 if (indexOfFirstFieldBinding == 1) {
 520                                         //the field is the first token of the qualified reference....
 521                                         if (scope.methodScope().isStatic) {
 522                                                 scope.problemReporter().staticFieldAccessToNonStaticVariable(
 523                                                         this,
 524                                                         (FieldBinding) binding);
 525                                                 return null;
 526                                         }
 527                                 } else { //accessing to a field using a type as "receiver" is allowed only with static field
 528                                         scope.problemReporter().staticFieldAccessToNonStaticVariable(
 529                                                 this,
 530                                                 (FieldBinding) binding);
 531                                         return null;
 532                                 }
 533                         }
 534                         if (isFieldUseDeprecated((FieldBinding) binding, scope))
 535                                 scope.problemReporter().deprecatedField((FieldBinding) binding, this);
 536                 }
 537                 TypeBinding type = ((VariableBinding) binding).type;
 538                 int index = indexOfFirstFieldBinding;
 539                 int length = tokens.length;
 540                 if (index == length) { //       restrictiveFlag == FIELD
 541                         this.constant = FieldReference.getConstantFor((FieldBinding) binding, this, false, scope);
 542                         return type;
 543                 }
 544                 // allocation of the fieldBindings array        and its respective constants
 545                 int otherBindingsLength = length - index;
 546                 otherCodegenBindings = otherBindings = new FieldBinding[otherBindingsLength];
 547                 otherDepths = new int[otherBindingsLength];
 548
 549                 // fill the first constant (the one of the binding)
 550                 this.constant =
 551                         ((bits & FIELD) != 0)
 552                                 ? FieldReference.getConstantFor((FieldBinding) binding, this, false, scope)
 553                                 : ((VariableBinding) binding).constant;
 554                 // save first depth, since will be updated by visibility checks of other bindings
 555                 int firstDepth = (bits & DepthMASK) >> DepthSHIFT;
 556                 // iteration on each field
 557                 while (index < length) {
 558                         char[] token = tokens[index];
 559                         if (type == null)
 560                                 return null; // could not resolve type prior to this point
 561
 562                         bits &= ~DepthMASK; // flush previous depth if any
 563                         FieldBinding field = scope.getField(type, token, this);
 564                         int place = index - indexOfFirstFieldBinding;
 565                         otherBindings[place] = field;
 566                         otherDepths[place] = (bits & DepthMASK) >> DepthSHIFT;
 567                         if (field.isValidBinding()) {
 568                                 if (isFieldUseDeprecated(field, scope))
 569                                         scope.problemReporter().deprecatedField(field, this);
 570                                 Constant someConstant = FieldReference.getConstantFor(field, this, false, scope);
 571                                 // constant propagation can only be performed as long as the previous one is a constant too.
 572                                 if (this.constant != NotAConstant) {
 573                                         this.constant = someConstant;
 574                                 }
 575
 576                                 type = field.type;
 577                                 index++;
 578
 579                                 if (field.isStatic()) {
 580                                         // static field accessed through receiver? legal but unoptimal (optional warning)
 581                                         scope.problemReporter().unnecessaryReceiverForStaticField(this, field);
 582                                 }
 583
 584                         } else {
 585                                 constant = NotAConstant; //don't fill other constants slots...
 586                                 scope.problemReporter().invalidField(this, field, index, type);
 587                                 setDepth(firstDepth);
 588                                 return null;
 589                         }
 590                 }
 591                 setDepth(firstDepth);
 592                 return (otherBindings[otherBindingsLength - 1]).type;
 593         }
 594         public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {
 595                 //If inlinable field, forget the access emulation, the code gen will directly target it
 596                 if (((bits & DepthMASK) == 0) || (constant != NotAConstant)) {
 597                         return;
 598                 }
 599                 if ((bits & RestrictiveFlagMASK) == LOCAL) {
 600                         currentScope.emulateOuterAccess((LocalVariableBinding) binding);
 601                 }
 602         }
 603         public void manageSyntheticReadAccessIfNecessary(
 604                 BlockScope currentScope,
 605                 FieldBinding fieldBinding,
 606                 TypeBinding lastReceiverType,
 607                 int index) {
 608                 // index == 0 denotes the first fieldBinding, index > 0 denotes one of the 'otherBindings'
 609                 if (fieldBinding.constant != NotAConstant)
 610                         return;
 611                 if (fieldBinding.isPrivate()) { // private access
 612                         if (fieldBinding.declaringClass != currentScope.enclosingSourceType()) {
 613                                 if (syntheticReadAccessors == null) {
 614                                         if (otherBindings == null)
 615                                                 syntheticReadAccessors = new SyntheticAccessMethodBinding[1];
 616                                         else
 617                                                 syntheticReadAccessors =
 618                                                         new SyntheticAccessMethodBinding[otherBindings.length + 1];
 619                                 }
 620                                 syntheticReadAccessors[index] = ((SourceTypeBinding) fieldBinding.declaringClass).addSyntheticMethod(fieldBinding, true);
 621                                 currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
 622                                 return;
 623                         }
 624                 } else if (fieldBinding.isProtected()){
 625                         int depth = index == 0 ? (bits & DepthMASK) >> DepthSHIFT : otherDepths[index-1];
 626                         // implicit protected access (only for first one)
 627                         if (depth > 0 && (fieldBinding.declaringClass.getPackage()
 628                                                                 != currentScope.enclosingSourceType().getPackage())) {
 629                                 if (syntheticReadAccessors == null) {
 630                                         if (otherBindings == null)
 631                                                 syntheticReadAccessors = new SyntheticAccessMethodBinding[1];
 632                                         else
 633                                                 syntheticReadAccessors =
 634                                                         new SyntheticAccessMethodBinding[otherBindings.length + 1];
 635                                 }
 636                                 syntheticReadAccessors[index] =
 637                                         ((SourceTypeBinding) currentScope.enclosingSourceType().enclosingTypeAt(depth))
 638                                                                                         .addSyntheticMethod(fieldBinding, true);
 639                                 currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
 640                                 return;
 641                         }
 642                 }
 643                 // if the binding declaring class is not visible, need special action
 644                 // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
 645                 // NOTE: from target 1.2 on, field's declaring class is touched if any different from receiver type
 646 //              if (fieldBinding.declaringClass != lastReceiverType
 647 //                      && !lastReceiverType.isArrayType()
 648 //                      && fieldBinding.declaringClass != null
 649 //                      && fieldBinding.constant == NotAConstant
 650 //                      && ((currentScope.environment().options.targetJDK >= CompilerOptions.JDK1_2
 651 //                                      && (index > 0 || indexOfFirstFieldBinding > 1 || !fieldBinding.isStatic())
 652 //                                      && fieldBinding.declaringClass.id != T_Object)
 653 //                              || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
 654 //                      if (index == 0){
 655 //                              this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 656 //                      } else {
 657 //                              if (this.otherCodegenBindings == this.otherBindings){
 658 //                                      int l = this.otherBindings.length;
 659 //                                      System.arraycopy(this.otherBindings, 0, this.otherCodegenBindings = new FieldBinding[l], 0, l);
 660 //                              }
 661 //                              this.otherCodegenBindings[index-1] = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 662 //                      }
 663 //              }
 664         }
 665         /*
 666          * No need to emulate access to protected fields since not implicitly accessed
 667          */
 668         public void manageSyntheticWriteAccessIfNecessary(
 669                 BlockScope currentScope,
 670                 FieldBinding fieldBinding,
 671                 TypeBinding lastReceiverType) {
 672                 if (fieldBinding.isPrivate()) {
 673                         if (fieldBinding.declaringClass != currentScope.enclosingSourceType()) {
 674                                 syntheticWriteAccessor = ((SourceTypeBinding) fieldBinding.declaringClass)
 675                                                                                         .addSyntheticMethod(fieldBinding, false);
 676                                 currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
 677                                 return;
 678                         }
 679                 } else if (fieldBinding.isProtected()){
 680                         int depth = fieldBinding == binding ? (bits & DepthMASK) >> DepthSHIFT : otherDepths[otherDepths.length-1];
 681                         if (depth > 0 && (fieldBinding.declaringClass.getPackage()
 682                                                                 != currentScope.enclosingSourceType().getPackage())) {
 683                                 syntheticWriteAccessor = ((SourceTypeBinding) currentScope.enclosingSourceType().enclosingTypeAt(depth))
 684                                                                                         .addSyntheticMethod(fieldBinding, false);
 685                                 currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
 686                                 return;
 687                         }
 688                 }
 689                 // if the binding declaring class is not visible, need special action
 690                 // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
 691                 // NOTE: from target 1.2 on, field's declaring class is touched if any different from receiver type
 692 //              if (fieldBinding.declaringClass != lastReceiverType
 693 //                      && !lastReceiverType.isArrayType()
 694 //                      && fieldBinding.declaringClass != null
 695 //                      && fieldBinding.constant == NotAConstant
 696 //                      && ((currentScope.environment().options.targetJDK >= CompilerOptions.JDK1_2
 697 //                                      && (fieldBinding != binding || indexOfFirstFieldBinding > 1 || !fieldBinding.isStatic())
 698 //                                      && fieldBinding.declaringClass.id != T_Object)
 699 //                              || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
 700 //                      if (fieldBinding == binding){
 701 //                              this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 702 //                      } else {
 703 //                              if (this.otherCodegenBindings == this.otherBindings){
 704 //                                      int l = this.otherBindings.length;
 705 //                                      System.arraycopy(this.otherBindings, 0, this.otherCodegenBindings = new FieldBinding[l], 0, l);
 706 //                              }
 707 //                              this.otherCodegenBindings[this.otherCodegenBindings.length-1] = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 708 //                      }
 709 //              }
 710
 711         }
 712         /**
 713          * Normal field binding did not work, try to bind to a field of the delegate receiver.
 714          */
 715         public TypeBinding reportError(BlockScope scope) {
 716                 if (binding instanceof ProblemFieldBinding) {
 717                         scope.problemReporter().invalidField(this, (FieldBinding) binding);
 718                 } else if (binding instanceof ProblemReferenceBinding) {
 719                         scope.problemReporter().invalidType(this, (TypeBinding) binding);
 720                 } else {
 721                         scope.problemReporter().unresolvableReference(this, binding);
 722                 }
 723                 return null;
 724         }
 725         public TypeBinding resolveType(BlockScope scope) {
 726                 // field and/or local are done before type lookups
 727                 // the only available value for the restrictiveFlag BEFORE
 728                 // the TC is Flag_Type Flag_LocalField and Flag_TypeLocalField
 729                 this.actualReceiverType = this.receiverType = scope.enclosingSourceType();
 730                 constant = Constant.NotAConstant;
 731                 if ((this.codegenBinding = this.binding = scope.getBinding(tokens, bits & RestrictiveFlagMASK, this))
 732                         .isValidBinding()) {
 733                         switch (bits & RestrictiveFlagMASK) {
 734                                 case VARIABLE : //============only variable===========
 735                                 case TYPE | VARIABLE :
 736                                         if (binding instanceof LocalVariableBinding) {
 737                                                 if (!((LocalVariableBinding) binding).isFinal() && ((bits & DepthMASK) != 0))
 738                                                         scope.problemReporter().cannotReferToNonFinalOuterLocal(
 739                                                                 (LocalVariableBinding) binding,
 740                                                                 this);
 741                                                 bits &= ~RestrictiveFlagMASK; // clear bits
 742                                                 bits |= LOCAL;
 743                                                 return this.resolvedType = getOtherFieldBindings(scope);
 744                                         }
 745                                         if (binding instanceof FieldBinding) {
 746                                                 // check for forward references
 747                                                 FieldBinding fieldBinding = (FieldBinding) binding;
 748                                                 MethodScope methodScope = scope.methodScope();
 749                                                 if (methodScope.enclosingSourceType() == fieldBinding.declaringClass
 750                                                         && methodScope.fieldDeclarationIndex != MethodScope.NotInFieldDecl
 751                                                         && fieldBinding.id >= methodScope.fieldDeclarationIndex) {
 752                                                         if ((!fieldBinding.isStatic() || methodScope.isStatic)
 753                                                                 && this.indexOfFirstFieldBinding == 1)
 754                                                                 scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
 755                                                 }
 756                                                 bits &= ~RestrictiveFlagMASK; // clear bits
 757                                                 bits |= FIELD;
 758
 759                                                 // check for deprecated receiver type
 760                                                 // deprecation check for receiver type if not first token
 761                                                 if (indexOfFirstFieldBinding > 1) {
 762                                                         if (isTypeUseDeprecated(this.actualReceiverType, scope))
 763                                                                 scope.problemReporter().deprecatedType(this.actualReceiverType, this);
 764                                                 }
 765
 766                                                 return this.resolvedType = getOtherFieldBindings(scope);
 767                                         }
 768                                         // thus it was a type
 769                                         bits &= ~RestrictiveFlagMASK; // clear bits
 770                                         bits |= TYPE;
 771                                 case TYPE : //=============only type ==============
 772                                         if (isTypeUseDeprecated((TypeBinding) binding, scope))
 773                                                 scope.problemReporter().deprecatedType((TypeBinding) binding, this);
 774                                         return this.resolvedType = (TypeBinding) binding;
 775                         }
 776                 }
 777                 //========error cases===============
 778                 return this.resolvedType = this.reportError(scope);
 779         }
 780         public void setFieldIndex(int index) {
 781                 this.indexOfFirstFieldBinding = index;
 782         }
 783         public String toStringExpression() {
 784                 StringBuffer buffer = new StringBuffer();
 785                 for (int i = 0; i < tokens.length; i++) {
 786                         buffer.append(tokens[i]);
 787                         if (i < (tokens.length - 1)) {
 788                                 buffer.append("."); //$NON-NLS-1$
 789                         }
 790                 }
 791                 return buffer.toString();
 792         }
 793         public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
 794                 visitor.visit(this, scope);
 795                 visitor.endVisit(this, scope);
 796         }
 797         public String unboundReferenceErrorName() {
 798                 return new String(tokens[0]);
 799         }
 800 }