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

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  ******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.ast;
  12
  13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
  14 import net.sourceforge.phpdt.internal.compiler.codegen.CodeStream;
  15 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
  16 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  17 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
  18 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  20 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
  21 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
  22 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
  23 import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
  24 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemFieldBinding;
  25 import net.sourceforge.phpdt.internal.compiler.lookup.ProblemReferenceBinding;
  26 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
  27 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
  28 import net.sourceforge.phpdt.internal.compiler.lookup.SyntheticAccessMethodBinding;
  29 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  30 import net.sourceforge.phpdt.internal.compiler.lookup.VariableBinding;
  31
  32 public class QualifiedNameReference extends NameReference {
  33
  34         public char[][] tokens;
  35         public FieldBinding[] otherBindings, otherCodegenBindings;
  36         int[] otherDepths;
  37         public int indexOfFirstFieldBinding;//points (into tokens) for the first token that corresponds to first FieldBinding
  38         SyntheticAccessMethodBinding syntheticWriteAccessor;
  39         SyntheticAccessMethodBinding[] syntheticReadAccessors;
  40         protected FieldBinding lastFieldBinding;
  41         public QualifiedNameReference(
  42                 char[][] sources,
  43                 int sourceStart,
  44                 int sourceEnd) {
  45                 super();
  46                 tokens = sources;
  47                 this.sourceStart = sourceStart;
  48                 this.sourceEnd = sourceEnd;
  49         }
  50         public FlowInfo analyseAssignment(
  51                 BlockScope currentScope,
  52                 FlowContext flowContext,
  53                 FlowInfo flowInfo,
  54                 Assignment assignment,
  55                 boolean isCompound) {
  56
  57                 if (assignment.expression != null) {
  58                         flowInfo =
  59                                 assignment
  60                                         .expression
  61                                         .analyseCode(currentScope, flowContext, flowInfo)
  62                                         .unconditionalInits();
  63                 }
  64                 // determine the rank until which we now we do not need any actual value for the field access
  65                 int otherBindingsCount = otherBindings == null ? 0 : otherBindings.length;
  66                 int indexOfFirstValueRequired = otherBindingsCount;
  67                 while (indexOfFirstValueRequired > 0) {
  68                         FieldBinding otherBinding = otherBindings[indexOfFirstValueRequired - 1];
  69                         if (otherBinding.isStatic())
  70                                 break; // no longer need any value before this point
  71                         indexOfFirstValueRequired--;
  72                 }
  73                 FieldBinding lastFieldBinding = null;
  74                 if ((bits & FIELD) != 0) {
  75                         // reading from a field
  76                         // check if final blank field
  77                         if ((lastFieldBinding = (FieldBinding) binding).isFinal()
  78                                 && currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)) {
  79                                 if (!flowInfo.isDefinitelyAssigned(lastFieldBinding)) {
  80                                         currentScope.problemReporter().uninitializedBlankFinalField(
  81                                                 lastFieldBinding,
  82                                                 this);
  83                                 }
  84                         }
  85                 } else {
  86                         if ((bits & LOCAL) != 0) {
  87                                 // first binding is a local variable
  88                                 LocalVariableBinding localBinding;
  89                                 if (!flowInfo
  90                                         .isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
  91                                         currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
  92                                 }
  93                                 if (!flowInfo.isFakeReachable())
  94                                         localBinding.used = true;
  95                         }
  96                 }
  97                 if (indexOfFirstValueRequired == 0) {
  98                         manageEnclosingInstanceAccessIfNecessary(currentScope);
  99                         // only for first binding
 100                 }
 101                 // all intermediate field accesses are read accesses
 102                 if (otherBindings != null) {
 103                         int start = indexOfFirstValueRequired == 0 ? 0 : indexOfFirstValueRequired - 1;
 104                         for (int i = start; i < otherBindingsCount; i++) {
 105                                 if (lastFieldBinding != null) { // could be null if first was a local variable
 106                                         TypeBinding lastReceiverType;
 107                                         switch(i){
 108                                                 case 0 :
 109                                                         lastReceiverType = this.actualReceiverType;
 110                                                         break;
 111                                                 case 1 :
 112                                                         lastReceiverType = ((VariableBinding)binding).type;
 113                                                         break;
 114                                                 default :
 115                                                         lastReceiverType = otherBindings[i-1].type;
 116                                         }
 117                                         manageSyntheticReadAccessIfNecessary(
 118                                                 currentScope,
 119                                                 lastFieldBinding,
 120                                                 lastReceiverType,
 121                                                 i);
 122                                 }
 123                                 lastFieldBinding = otherBindings[i];
 124                         }
 125                 }
 126                 if (isCompound) {
 127                         if (binding == lastFieldBinding
 128                                 && currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)
 129                                 && (!flowInfo.isDefinitelyAssigned(lastFieldBinding))) {
 130                                 currentScope.problemReporter().uninitializedBlankFinalField(
 131                                         lastFieldBinding,
 132                                         this);
 133                         }
 134                         TypeBinding lastReceiverType;
 135                         if (lastFieldBinding == binding){
 136                                 lastReceiverType = this.actualReceiverType;
 137                         } else if (otherBindingsCount == 1){
 138                                 lastReceiverType = ((VariableBinding)this.binding).type;
 139                         } else {
 140                                 lastReceiverType = this.otherBindings[otherBindingsCount-2].type;
 141                         }
 142                         manageSyntheticReadAccessIfNecessary(
 143                                 currentScope,
 144                                 lastFieldBinding,
 145                                 lastReceiverType,
 146                                 lastFieldBinding == binding
 147                                         ? 0
 148                                         : otherBindingsCount);
 149                 }
 150                 // the last field access is a write access
 151                 if (lastFieldBinding.isFinal()) {
 152                         // in a context where it can be assigned?
 153                         if (currentScope.allowBlankFinalFieldAssignment(lastFieldBinding)) {
 154                                 if (flowInfo.isPotentiallyAssigned(lastFieldBinding)) {
 155                                         if (indexOfFirstFieldBinding == 1) {
 156                                                 // was an implicit reference to the first field binding
 157                                                 currentScope.problemReporter().duplicateInitializationOfBlankFinalField(
 158                                                         lastFieldBinding,
 159                                                         this);
 160                                         } else {
 161                                                 currentScope.problemReporter().cannotAssignToFinalField(lastFieldBinding, this);
 162                                                 // attempting to assign a non implicit reference
 163                                         }
 164                                 }
 165                                 flowInfo.markAsDefinitelyAssigned(lastFieldBinding);
 166                                 flowContext.recordSettingFinal(lastFieldBinding, this);
 167                         } else {
 168                                 currentScope.problemReporter().cannotAssignToFinalField(lastFieldBinding, this);
 169                         }
 170                 }
 171                 // equivalent to valuesRequired[maxOtherBindings]
 172                 TypeBinding lastReceiverType;
 173                 if (lastFieldBinding == binding){
 174                         lastReceiverType = this.actualReceiverType;
 175                 } else if (otherBindingsCount == 1){
 176                         lastReceiverType = ((VariableBinding)this.binding).type;
 177                 } else {
 178                         lastReceiverType = this.otherBindings[otherBindingsCount-2].type;
 179                 }
 180                 manageSyntheticWriteAccessIfNecessary(currentScope, lastFieldBinding, lastReceiverType);
 181
 182                 return flowInfo;
 183         }
 184         public FlowInfo analyseCode(
 185                 BlockScope currentScope,
 186                 FlowContext flowContext,
 187                 FlowInfo flowInfo) {
 188
 189                 return analyseCode(currentScope, flowContext, flowInfo, true);
 190         }
 191
 192         public FlowInfo analyseCode(
 193                 BlockScope currentScope,
 194                 FlowContext flowContext,
 195                 FlowInfo flowInfo,
 196                 boolean valueRequired) {
 197
 198                 // determine the rank until which we now we do not need any actual value for the field access
 199                 int otherBindingsCount = otherBindings == null ? 0 : otherBindings.length;
 200                 int indexOfFirstValueRequired;
 201                 if (valueRequired) {
 202                         indexOfFirstValueRequired = otherBindingsCount;
 203                         while (indexOfFirstValueRequired > 0) {
 204                                 FieldBinding otherBinding = otherBindings[indexOfFirstValueRequired - 1];
 205                                 if (otherBinding.isStatic())
 206                                         break; // no longer need any value before this point
 207                                 indexOfFirstValueRequired--;
 208                         }
 209                 } else {
 210                         indexOfFirstValueRequired = otherBindingsCount + 1;
 211                 }
 212                 switch (bits & RestrictiveFlagMASK) {
 213                         case FIELD : // reading a field
 214                                 if (indexOfFirstValueRequired == 0) {
 215                                         manageSyntheticReadAccessIfNecessary(currentScope, (FieldBinding) binding, this.actualReceiverType, 0);
 216                                 }
 217                                 // check if reading a final blank field
 218                                 FieldBinding fieldBinding;
 219                                         if ((fieldBinding = (FieldBinding) binding).isFinal()
 220                                                 && (indexOfFirstFieldBinding == 1)
 221                                         // was an implicit reference to the first field binding
 222                                                 && currentScope.allowBlankFinalFieldAssignment(fieldBinding)
 223                                                 && (!flowInfo.isDefinitelyAssigned(fieldBinding))) {
 224                                         currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
 225                                 }
 226                                 break;
 227                         case LOCAL : // reading a local variable
 228                                 LocalVariableBinding localBinding;
 229                                 if (!flowInfo
 230                                         .isDefinitelyAssigned(localBinding = (LocalVariableBinding) binding)) {
 231                                         currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
 232                                 }
 233                                 if (!flowInfo.isFakeReachable())
 234                                         localBinding.used = true;
 235                 }
 236                 if (indexOfFirstValueRequired == 0) {
 237                         manageEnclosingInstanceAccessIfNecessary(currentScope);
 238                         // only for first binding
 239                 }
 240                 if (otherBindings != null) {
 241                         int start = indexOfFirstValueRequired == 0 ? 0 : indexOfFirstValueRequired - 1;
 242                         for (int i = start; i < otherBindingsCount; i++) {
 243                                 manageSyntheticReadAccessIfNecessary(
 244                                         currentScope,
 245                                         otherBindings[i],
 246                                         i == 0
 247                                                 ? ((VariableBinding)binding).type
 248                                                 : otherBindings[i-1].type,
 249                                         i + 1);
 250                         }
 251                 }
 252                 return flowInfo;
 253         }
 254         /**
 255          * Check and/or redirect the field access to the delegate receiver if any
 256          */
 257         public TypeBinding checkFieldAccess(BlockScope scope) {
 258                 // check for forward references
 259                 FieldBinding fieldBinding = (FieldBinding) binding;
 260                 MethodScope methodScope = scope.methodScope();
 261                 if (methodScope.enclosingSourceType() == fieldBinding.declaringClass
 262                         && methodScope.fieldDeclarationIndex != MethodScope.NotInFieldDecl
 263                         && fieldBinding.id >= methodScope.fieldDeclarationIndex) {
 264                         if ((!fieldBinding.isStatic() || methodScope.isStatic)
 265                                 && this.indexOfFirstFieldBinding == 1)
 266                                 scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
 267                 }
 268                 bits &= ~RestrictiveFlagMASK; // clear bits
 269                 bits |= FIELD;
 270                 return getOtherFieldBindings(scope);
 271         }
 272         public void generateAssignment(
 273                 BlockScope currentScope,
 274                 CodeStream codeStream,
 275                 Assignment assignment,
 276                 boolean valueRequired) {
 277
 278                 generateReadSequence(currentScope, codeStream, true);
 279                 assignment.expression.generateCode(currentScope, codeStream, true);
 280                 fieldStore(codeStream, lastFieldBinding, syntheticWriteAccessor, valueRequired);
 281                 // equivalent to valuesRequired[maxOtherBindings]
 282                 if (valueRequired) {
 283                         codeStream.generateImplicitConversion(assignment.implicitConversion);
 284                 }
 285         }
 286         public void generateCode(
 287                 BlockScope currentScope,
 288                 CodeStream codeStream,
 289                 boolean valueRequired) {
 290                 int pc = codeStream.position;
 291                 if (constant != NotAConstant) {
 292                         if (valueRequired) {
 293                                 codeStream.generateConstant(constant, implicitConversion);
 294                         }
 295                 } else {
 296                         generateReadSequence(currentScope, codeStream, valueRequired);
 297                         if (valueRequired) {
 298                                 if (lastFieldBinding.declaringClass == null) { // array length
 299                                         codeStream.arraylength();
 300                                         codeStream.generateImplicitConversion(implicitConversion);
 301                                 } else {
 302                                         if (lastFieldBinding.constant != NotAConstant) {
 303                                                 // inline the last field constant
 304                                                 codeStream.generateConstant(lastFieldBinding.constant, implicitConversion);
 305                                         } else {
 306                                                 SyntheticAccessMethodBinding accessor =
 307                                                         syntheticReadAccessors == null
 308                                                                 ? null
 309                                                                 : syntheticReadAccessors[syntheticReadAccessors.length - 1];
 310                                                 if (accessor == null) {
 311                                                         if (lastFieldBinding.isStatic()) {
 312                                                                 codeStream.getstatic(lastFieldBinding);
 313                                                         } else {
 314                                                                 codeStream.getfield(lastFieldBinding);
 315                                                         }
 316                                                 } else {
 317                                                         codeStream.invokestatic(accessor);
 318                                                 }
 319                                                 codeStream.generateImplicitConversion(implicitConversion);
 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, true);
 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, true);
 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                 boolean valueRequired) {
 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                 int indexOfFirstValueRequired;
 437                 if (valueRequired) {
 438                         indexOfFirstValueRequired = otherBindingsCount;
 439                         while (indexOfFirstValueRequired > 0) {
 440                                 FieldBinding otherBinding = this.otherCodegenBindings[indexOfFirstValueRequired - 1];
 441                                 if (otherBinding.isStatic() || otherBinding.constant != NotAConstant)
 442                                         break; // no longer need any value before this point
 443                                 indexOfFirstValueRequired--;
 444                         }
 445                 } else {
 446                         indexOfFirstValueRequired = otherBindingsCount + 1;
 447                 }
 448                 if (indexOfFirstValueRequired == 0) {
 449                         switch (bits & RestrictiveFlagMASK) {
 450                                 case FIELD :
 451                                         lastFieldBinding = (FieldBinding) this.codegenBinding;
 452                                         // if first field is actually constant, we can inline it
 453                                         if (lastFieldBinding.constant != NotAConstant) {
 454                                                 codeStream.generateConstant(lastFieldBinding.constant, 0);
 455                                                 // no implicit conversion
 456                                                 lastFieldBinding = null; // will not generate it again
 457                                                 break;
 458                                         }
 459                                         if (!lastFieldBinding.isStatic()) {
 460                                                 if ((bits & DepthMASK) != 0) {
 461                                                         Object[] emulationPath =
 462                                                                 currentScope.getExactEmulationPath(
 463                                                                         currentScope.enclosingSourceType().enclosingTypeAt(
 464                                                                                 (bits & DepthMASK) >> DepthSHIFT));
 465                                                         if (emulationPath == null) {
 466                                                                 // internal error, per construction we should have found it
 467                                                                 currentScope.problemReporter().needImplementation();
 468                                                         } else {
 469                                                                 codeStream.generateOuterAccess(emulationPath, this, currentScope);
 470                                                         }
 471                                                 } else {
 472                                                         generateReceiver(codeStream);
 473                                                 }
 474                                         }
 475                                         break;
 476                                 case LOCAL : // reading the first local variable
 477                                         lastFieldBinding = null;
 478                                         LocalVariableBinding localBinding = (LocalVariableBinding) this.codegenBinding;
 479                                         // regular local variable read
 480                                         if (localBinding.constant != NotAConstant) {
 481                                                 codeStream.generateConstant(localBinding.constant, 0);
 482                                                 // no implicit conversion
 483                                         } else {
 484                                                 // outer local?
 485                                                 if ((bits & DepthMASK) != 0) {
 486                                                         // outer local can be reached either through a synthetic arg or a synthetic field
 487                                                         VariableBinding[] path = currentScope.getEmulationPath(localBinding);
 488                                                         if (path == null) {
 489                                                                 // emulation was not possible (should not happen per construction)
 490                                                                 currentScope.problemReporter().needImplementation();
 491                                                         } else {
 492                                                                 codeStream.generateOuterAccess(path, this, currentScope);
 493                                                         }
 494                                                 } else {
 495                                                         codeStream.load(localBinding);
 496                                                 }
 497                                         }
 498                         }
 499                 } else {
 500                         lastFieldBinding = null;
 501                 }
 502                 // all intermediate field accesses are read accesses
 503                 // only the last field binding is a write access
 504                 if (this.otherCodegenBindings != null) {
 505                         int start = indexOfFirstValueRequired == 0 ? 0 : indexOfFirstValueRequired - 1;
 506                         for (int i = start; i < otherBindingsCount; i++) {
 507                                 if (lastFieldBinding != null) {
 508                                         MethodBinding accessor =
 509                                                 syntheticReadAccessors == null ? null : syntheticReadAccessors[i];
 510                                         if (accessor == null)
 511                                                 if (lastFieldBinding.isStatic())
 512                                                         codeStream.getstatic(lastFieldBinding);
 513                                                 else
 514                                                         codeStream.getfield(lastFieldBinding);
 515                                         else
 516                                                 codeStream.invokestatic(accessor);
 517                                 }
 518                                 lastFieldBinding = otherCodegenBindings[i];
 519                         }
 520                 }
 521         }
 522         public void generateReceiver(CodeStream codeStream) {
 523                 codeStream.aload_0();
 524         }
 525         public TypeBinding getOtherFieldBindings(BlockScope scope) {
 526                 // At this point restrictiveFlag may ONLY have two potential value : FIELD LOCAL (i.e cast <<(VariableBinding) binding>> is valid)
 527                 if ((bits & FIELD) != 0) {
 528                         if (!((FieldBinding) binding).isStatic()) {
 529                                 //must check for the static status....
 530                                 if (indexOfFirstFieldBinding == 1) {
 531                                         //the field is the first token of the qualified reference....
 532                                         if (scope.methodScope().isStatic) {
 533                                                 scope.problemReporter().staticFieldAccessToNonStaticVariable(
 534                                                         this,
 535                                                         (FieldBinding) binding);
 536                                                 return null;
 537                                         }
 538                                 } else { //accessing to a field using a type as "receiver" is allowed only with static field
 539                                         scope.problemReporter().staticFieldAccessToNonStaticVariable(
 540                                                 this,
 541                                                 (FieldBinding) binding);
 542                                         return null;
 543                                 }
 544                         }
 545                         if (isFieldUseDeprecated((FieldBinding) binding, scope))
 546                                 scope.problemReporter().deprecatedField((FieldBinding) binding, this);
 547                 }
 548                 TypeBinding type = ((VariableBinding) binding).type;
 549                 int index = indexOfFirstFieldBinding;
 550                 int length = tokens.length;
 551                 if (index == length) { //       restrictiveFlag == FIELD
 552                         constant =
 553                                 FieldReference.getConstantFor((FieldBinding) binding, false, this, scope, index - 1);
 554                         return type;
 555                 }
 556                 // allocation of the fieldBindings array        and its respective constants
 557                 int otherBindingsLength = length - index;
 558                 otherCodegenBindings = otherBindings = new FieldBinding[otherBindingsLength];
 559                 otherDepths = new int[otherBindingsLength];
 560
 561                 // fill the first constant (the one of the binding)
 562                 constant =
 563                         ((bits & FIELD) != 0)
 564                                 ? FieldReference.getConstantFor((FieldBinding) binding, false, this, scope, index - 1)
 565                                 : ((VariableBinding) binding).constant;
 566                 // save first depth, since will be updated by visibility checks of other bindings
 567                 int firstDepth = (bits & DepthMASK) >> DepthSHIFT;
 568                 // iteration on each field
 569                 while (index < length) {
 570                         char[] token = tokens[index];
 571                         if (type == null)
 572                                 return null; // could not resolve type prior to this point
 573
 574                         bits &= ~DepthMASK; // flush previous depth if any
 575                         FieldBinding field = scope.getField(type, token, this);
 576                         int place = index - indexOfFirstFieldBinding;
 577                         otherBindings[place] = field;
 578                         otherDepths[place] = (bits & DepthMASK) >> DepthSHIFT;
 579                         if (field.isValidBinding()) {
 580                                 if (isFieldUseDeprecated(field, scope))
 581                                         scope.problemReporter().deprecatedField(field, this);
 582                                 Constant someConstant =
 583                                         FieldReference.getConstantFor(field, false, this, scope, place);
 584                                 // constant propagation can only be performed as long as the previous one is a constant too.
 585                                 if (constant != NotAConstant) {
 586                                         constant = someConstant;
 587                                 }
 588                                 type = field.type;
 589                                 index++;
 590                         } else {
 591                                 constant = NotAConstant; //don't fill other constants slots...
 592                                 scope.problemReporter().invalidField(this, field, index, type);
 593                                 setDepth(firstDepth);
 594                                 return null;
 595                         }
 596                 }
 597                 setDepth(firstDepth);
 598                 return (otherBindings[otherBindingsLength - 1]).type;
 599         }
 600         public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {
 601                 //If inlinable field, forget the access emulation, the code gen will directly target it
 602                 if (((bits & DepthMASK) == 0) || (constant != NotAConstant)) {
 603                         return;
 604                 }
 605                 switch (bits & RestrictiveFlagMASK) {
 606                         case FIELD :
 607                                 FieldBinding fieldBinding;
 608                                 if ((fieldBinding = (FieldBinding) binding).isStatic()
 609                                         || (fieldBinding.constant != NotAConstant))
 610                                         return;
 611                                 ReferenceBinding compatibleType = currentScope.enclosingSourceType();
 612                                 // the declaringClass of the target binding must be compatible with the enclosing
 613                                 // type at <depth> levels outside
 614                                 for (int i = 0, depth = (bits & DepthMASK) >> DepthSHIFT; i < depth; i++) {
 615                                         compatibleType = compatibleType.enclosingType();
 616                                 }
 617                                 currentScope.emulateOuterAccess(compatibleType, false);
 618                                 // request cascade of accesses
 619                                 break;
 620                         case LOCAL :
 621                                 currentScope.emulateOuterAccess((LocalVariableBinding) binding);
 622                 }
 623         }
 624         public void manageSyntheticReadAccessIfNecessary(
 625                 BlockScope currentScope,
 626                 FieldBinding fieldBinding,
 627                 TypeBinding lastReceiverType,
 628                 int index) {
 629                 // index == 0 denotes the first fieldBinding, index > 0 denotes one of the 'otherBindings'
 630                 if (fieldBinding.constant != NotAConstant)
 631                         return;
 632                 if (fieldBinding.isPrivate()) { // private access
 633                         if (fieldBinding.declaringClass != currentScope.enclosingSourceType()) {
 634                                 if (syntheticReadAccessors == null) {
 635                                         if (otherBindings == null)
 636                                                 syntheticReadAccessors = new SyntheticAccessMethodBinding[1];
 637                                         else
 638                                                 syntheticReadAccessors =
 639                                                         new SyntheticAccessMethodBinding[otherBindings.length + 1];
 640                                 }
 641                                 syntheticReadAccessors[index] = ((SourceTypeBinding) fieldBinding.declaringClass).addSyntheticMethod(fieldBinding, true);
 642                                 currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
 643                                 return;
 644                         }
 645                 } else if (fieldBinding.isProtected()){
 646                         int depth = index == 0 ? (bits & DepthMASK) >> DepthSHIFT : otherDepths[index-1];
 647                         // implicit protected access (only for first one)
 648                         if (depth > 0 && (fieldBinding.declaringClass.getPackage()
 649                                                                 != currentScope.enclosingSourceType().getPackage())) {
 650                                 if (syntheticReadAccessors == null) {
 651                                         if (otherBindings == null)
 652                                                 syntheticReadAccessors = new SyntheticAccessMethodBinding[1];
 653                                         else
 654                                                 syntheticReadAccessors =
 655                                                         new SyntheticAccessMethodBinding[otherBindings.length + 1];
 656                                 }
 657                                 syntheticReadAccessors[index] =
 658                                         ((SourceTypeBinding) currentScope.enclosingSourceType().enclosingTypeAt(depth))
 659                                                                                         .addSyntheticMethod(fieldBinding, true);
 660                                 currentScope.problemReporter().needToEmulateFieldReadAccess(fieldBinding, this);
 661                                 return;
 662                         }
 663                 }
 664                 // if the binding declaring class is not visible, need special action
 665                 // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
 666                 // NOTE: from 1.4 on, field's declaring class is touched if any different from receiver type
 667                 if (fieldBinding.declaringClass != lastReceiverType
 668                         && !lastReceiverType.isArrayType()
 669                         && fieldBinding.declaringClass != null
 670                         && fieldBinding.constant == NotAConstant
 671                         && ((currentScope.environment().options.complianceLevel >= CompilerOptions.JDK1_4
 672                                         && (index > 0 || indexOfFirstFieldBinding > 1 || !fieldBinding.isStatic())
 673                                         && fieldBinding.declaringClass.id != T_Object)
 674                                 || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
 675                         if (index == 0){
 676                                 this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 677                         } else {
 678                                 if (this.otherCodegenBindings == this.otherBindings){
 679                                         int l = this.otherBindings.length;
 680                                         System.arraycopy(this.otherBindings, 0, this.otherCodegenBindings = new FieldBinding[l], 0, l);
 681                                 }
 682                                 this.otherCodegenBindings[index-1] = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 683                         }
 684                 }
 685         }
 686         /*
 687          * No need to emulate access to protected fields since not implicitly accessed
 688          */
 689         public void manageSyntheticWriteAccessIfNecessary(
 690                 BlockScope currentScope,
 691                 FieldBinding fieldBinding,
 692                 TypeBinding lastReceiverType) {
 693                 if (fieldBinding.isPrivate()) {
 694                         if (fieldBinding.declaringClass != currentScope.enclosingSourceType()) {
 695                                 syntheticWriteAccessor = ((SourceTypeBinding) fieldBinding.declaringClass)
 696                                                                                         .addSyntheticMethod(fieldBinding, false);
 697                                 currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
 698                                 return;
 699                         }
 700                 } else if (fieldBinding.isProtected()){
 701                         int depth = fieldBinding == binding ? (bits & DepthMASK) >> DepthSHIFT : otherDepths[otherDepths.length-1];
 702                         if (depth > 0 && (fieldBinding.declaringClass.getPackage()
 703                                                                 != currentScope.enclosingSourceType().getPackage())) {
 704                                 syntheticWriteAccessor = ((SourceTypeBinding) currentScope.enclosingSourceType().enclosingTypeAt(depth))
 705                                                                                         .addSyntheticMethod(fieldBinding, false);
 706                                 currentScope.problemReporter().needToEmulateFieldWriteAccess(fieldBinding, this);
 707                                 return;
 708                         }
 709                 }
 710                 // if the binding declaring class is not visible, need special action
 711                 // for runtime compatibility on 1.2 VMs : change the declaring class of the binding
 712                 // NOTE: from 1.4 on, field's declaring class is touched if any different from receiver type
 713                 if (fieldBinding.declaringClass != lastReceiverType
 714                         && !lastReceiverType.isArrayType()
 715                         && fieldBinding.declaringClass != null
 716                         && fieldBinding.constant == NotAConstant
 717                         && ((currentScope.environment().options.complianceLevel >= CompilerOptions.JDK1_4
 718                                         && (fieldBinding != binding || indexOfFirstFieldBinding > 1 || !fieldBinding.isStatic())
 719                                         && fieldBinding.declaringClass.id != T_Object)
 720                                 || !fieldBinding.declaringClass.canBeSeenBy(currentScope))){
 721                         if (fieldBinding == binding){
 722                                 this.codegenBinding = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 723                         } else {
 724                                 if (this.otherCodegenBindings == this.otherBindings){
 725                                         int l = this.otherBindings.length;
 726                                         System.arraycopy(this.otherBindings, 0, this.otherCodegenBindings = new FieldBinding[l], 0, l);
 727                                 }
 728                                 this.otherCodegenBindings[this.otherCodegenBindings.length-1] = currentScope.enclosingSourceType().getUpdatedFieldBinding(fieldBinding, (ReferenceBinding)lastReceiverType);
 729                         }
 730                 }
 731
 732         }
 733         /**
 734          * Normal field binding did not work, try to bind to a field of the delegate receiver.
 735          */
 736         public TypeBinding reportError(BlockScope scope) {
 737                 if (binding instanceof ProblemFieldBinding) {
 738                         scope.problemReporter().invalidField(this, (FieldBinding) binding);
 739                 } else if (binding instanceof ProblemReferenceBinding) {
 740                         scope.problemReporter().invalidType(this, (TypeBinding) binding);
 741                 } else {
 742                         scope.problemReporter().unresolvableReference(this, binding);
 743                 }
 744                 return null;
 745         }
 746         public TypeBinding resolveType(BlockScope scope) {
 747                 // field and/or local are done before type lookups
 748                 // the only available value for the restrictiveFlag BEFORE
 749                 // the TC is Flag_Type Flag_LocalField and Flag_TypeLocalField
 750                 this.actualReceiverType = this.receiverType = scope.enclosingSourceType();
 751                 constant = Constant.NotAConstant;
 752                 if ((this.codegenBinding = this.binding = scope.getBinding(tokens, bits & RestrictiveFlagMASK, this))
 753                         .isValidBinding()) {
 754                         switch (bits & RestrictiveFlagMASK) {
 755                                 case VARIABLE : //============only variable===========
 756                                 case TYPE | VARIABLE :
 757                                         if (binding instanceof LocalVariableBinding) {
 758                                                 if (!((LocalVariableBinding) binding).isFinal() && ((bits & DepthMASK) != 0))
 759                                                         scope.problemReporter().cannotReferToNonFinalOuterLocal(
 760                                                                 (LocalVariableBinding) binding,
 761                                                                 this);
 762                                                 bits &= ~RestrictiveFlagMASK; // clear bits
 763                                                 bits |= LOCAL;
 764                                                 return getOtherFieldBindings(scope);
 765                                         }
 766                                         if (binding instanceof FieldBinding) {
 767                                                 // check for forward references
 768                                                 FieldBinding fieldBinding = (FieldBinding) binding;
 769                                                 MethodScope methodScope = scope.methodScope();
 770                                                 if (methodScope.enclosingSourceType() == fieldBinding.declaringClass
 771                                                         && methodScope.fieldDeclarationIndex != MethodScope.NotInFieldDecl
 772                                                         && fieldBinding.id >= methodScope.fieldDeclarationIndex) {
 773                                                         if ((!fieldBinding.isStatic() || methodScope.isStatic)
 774                                                                 && this.indexOfFirstFieldBinding == 1)
 775                                                                 scope.problemReporter().forwardReference(this, 0, scope.enclosingSourceType());
 776                                                 }
 777                                                 bits &= ~RestrictiveFlagMASK; // clear bits
 778                                                 bits |= FIELD;
 779                                                 return getOtherFieldBindings(scope);
 780                                         }
 781                                         // thus it was a type
 782                                         bits &= ~RestrictiveFlagMASK; // clear bits
 783                                         bits |= TYPE;
 784                                 case TYPE : //=============only type ==============
 785                                         //deprecated test
 786                                         if (isTypeUseDeprecated((TypeBinding) binding, scope))
 787                                                 scope.problemReporter().deprecatedType((TypeBinding) binding, this);
 788                                         return (TypeBinding) binding;
 789                         }
 790                 }
 791                 //========error cases===============
 792                 return this.reportError(scope);
 793         }
 794         public void setFieldIndex(int index) {
 795                 this.indexOfFirstFieldBinding = index;
 796         }
 797         public String toStringExpression() {
 798                 StringBuffer buffer = new StringBuffer();
 799                 for (int i = 0; i < tokens.length; i++) {
 800                         buffer.append(tokens[i]);
 801                         if (i < (tokens.length - 1)) {
 802                                 buffer.append("."); //$NON-NLS-1$
 803                         }
 804                 }
 805                 return buffer.toString();
 806         }
 807         public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
 808                 visitor.visit(this, scope);
 809                 visitor.endVisit(this, scope);
 810         }
 811         public String unboundReferenceErrorName() {
 812                 return new String(tokens[0]);
 813         }
 814 }