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