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