Minor changes in pages design.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / FieldReference.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.ASTVisitor;
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.BindingIds;
18 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
19 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
20 import net.sourceforge.phpdt.internal.compiler.lookup.InvocationSite;
21 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
22 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
23 import net.sourceforge.phpdt.internal.compiler.lookup.Scope;
24 import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
25 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
26
27 public class FieldReference extends Reference implements InvocationSite {
28
29         public Expression receiver;
30
31         public char[] token;
32
33         public FieldBinding binding, codegenBinding;
34
35         public long nameSourcePosition; // (start<<32)+end
36
37         MethodBinding syntheticReadAccessor, syntheticWriteAccessor;
38
39         public TypeBinding receiverType;
40
41         public FieldReference(char[] source, long pos) {
42
43                 token = source;
44                 nameSourcePosition = pos;
45                 // by default the position are the one of the field (not true for super
46                 // access)
47                 // sourceStart = (int) (pos >>> 32);
48                 // sourceEnd = (int) (pos & 0x00000000FFFFFFFFL);
49                 sourceStart = (int) pos;
50                 sourceEnd = sourceStart + source.length;
51                 bits |= BindingIds.FIELD;
52
53         }
54
55         public FlowInfo analyseAssignment(BlockScope currentScope,
56                         FlowContext flowContext, FlowInfo flowInfo, Assignment assignment,
57                         boolean isCompound) {
58
59                 // compound assignment extra work
60                 if (isCompound) { // check the variable part is initialized if blank
61                                                         // final
62                         if (binding.isBlankFinal() && receiver.isThis()
63                                         && currentScope.allowBlankFinalFieldAssignment(binding)
64                                         && (!flowInfo.isDefinitelyAssigned(binding))) {
65                                 currentScope.problemReporter().uninitializedBlankFinalField(
66                                                 binding, this);
67                                 // we could improve error msg here telling "cannot use compound
68                                 // assignment on final blank field"
69                         }
70                         manageSyntheticReadAccessIfNecessary(currentScope);
71                 }
72                 flowInfo = receiver.analyseCode(currentScope, flowContext, flowInfo,
73                                 !binding.isStatic()).unconditionalInits();
74                 if (assignment.expression != null) {
75                         flowInfo = assignment.expression.analyseCode(currentScope,
76                                         flowContext, flowInfo).unconditionalInits();
77                 }
78                 manageSyntheticWriteAccessIfNecessary(currentScope);
79
80                 // check if assigning a final field
81                 if (binding.isFinal()) {
82                         // in a context where it can be assigned?
83                         if (binding.isBlankFinal() && !isCompound && receiver.isThis()
84                                         && !(receiver instanceof QualifiedThisReference)
85                                         && ((receiver.bits & ParenthesizedMASK) == 0) // (this).x
86                                                                                                                                         // is
87                                                                                                                                         // forbidden
88                                         && currentScope.allowBlankFinalFieldAssignment(binding)) {
89                                 if (flowInfo.isPotentiallyAssigned(binding)) {
90                                         currentScope.problemReporter()
91                                                         .duplicateInitializationOfBlankFinalField(binding,
92                                                                         this);
93                                 } else {
94                                         flowContext.recordSettingFinal(binding, this);
95                                 }
96                                 flowInfo.markAsDefinitelyAssigned(binding);
97                         } else {
98                                 // assigning a final field outside an initializer or constructor
99                                 // or wrong reference
100                                 currentScope.problemReporter().cannotAssignToFinalField(
101                                                 binding, this);
102                         }
103                 }
104                 return flowInfo;
105         }
106
107         public FlowInfo analyseCode(BlockScope currentScope,
108                         FlowContext flowContext, FlowInfo flowInfo) {
109
110                 return analyseCode(currentScope, flowContext, flowInfo, true);
111         }
112
113         public FlowInfo analyseCode(BlockScope currentScope,
114                         FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
115
116                 receiver.analyseCode(currentScope, flowContext, flowInfo, !binding
117                                 .isStatic());
118                 if (valueRequired) {
119                         manageSyntheticReadAccessIfNecessary(currentScope);
120                 }
121                 return flowInfo;
122         }
123
124         public FieldBinding fieldBinding() {
125
126                 return binding;
127         }
128
129         // public void generateAssignment(
130         // BlockScope currentScope,
131         // CodeStream codeStream,
132         // Assignment assignment,
133         // boolean valueRequired) {
134         //
135         // receiver.generateCode(
136         // currentScope,
137         // codeStream,
138         // !this.codegenBinding.isStatic());
139         // assignment.expression.generateCode(currentScope, codeStream, true);
140         // fieldStore(
141         // codeStream,
142         // this.codegenBinding,
143         // syntheticWriteAccessor,
144         // valueRequired);
145         // if (valueRequired) {
146         // codeStream.generateImplicitConversion(assignment.implicitConversion);
147         // }
148         // }
149
150         /**
151          * Field reference code generation
152          * 
153          * @param currentScope
154          *            net.sourceforge.phpdt.internal.compiler.lookup.BlockScope
155          * @param codeStream
156          *            net.sourceforge.phpdt.internal.compiler.codegen.CodeStream
157          * @param valueRequired
158          *            boolean
159          */
160         // public void generateCode(
161         // BlockScope currentScope,
162         // CodeStream codeStream,
163         // boolean valueRequired) {
164         //
165         // int pc = codeStream.position;
166         // if (constant != NotAConstant) {
167         // if (valueRequired) {
168         // codeStream.generateConstant(constant, implicitConversion);
169         // }
170         // } else {
171         // boolean isStatic = this.codegenBinding.isStatic();
172         // receiver.generateCode(currentScope, codeStream, !isStatic);
173         // if (valueRequired) {
174         // if (this.codegenBinding.constant == NotAConstant) {
175         // if (this.codegenBinding.declaringClass == null) { // array length
176         // codeStream.arraylength();
177         // } else {
178         // if (syntheticReadAccessor == null) {
179         // if (isStatic) {
180         // codeStream.getstatic(this.codegenBinding);
181         // } else {
182         // codeStream.getfield(this.codegenBinding);
183         // }
184         // } else {
185         // codeStream.invokestatic(syntheticReadAccessor);
186         // }
187         // }
188         // codeStream.generateImplicitConversion(implicitConversion);
189         // } else {
190         // if (!isStatic) {
191         // codeStream.invokeObjectGetClass(); // perform null check
192         // codeStream.pop();
193         // }
194         // codeStream.generateConstant(this.codegenBinding.constant,
195         // implicitConversion);
196         // }
197         // } else {
198         // if (!isStatic){
199         // codeStream.invokeObjectGetClass(); // perform null check
200         // codeStream.pop();
201         // }
202         // }
203         // }
204         // codeStream.recordPositionsFrom(pc, this.sourceStart);
205         // }
206         //
207         // public void generateCompoundAssignment(
208         // BlockScope currentScope,
209         // CodeStream codeStream,
210         // Expression expression,
211         // int operator,
212         // int assignmentImplicitConversion,
213         // boolean valueRequired) {
214         //
215         // boolean isStatic;
216         // receiver.generateCode(
217         // currentScope,
218         // codeStream,
219         // !(isStatic = this.codegenBinding.isStatic()));
220         // if (isStatic) {
221         // if (syntheticReadAccessor == null) {
222         // codeStream.getstatic(this.codegenBinding);
223         // } else {
224         // codeStream.invokestatic(syntheticReadAccessor);
225         // }
226         // } else {
227         // codeStream.dup();
228         // if (syntheticReadAccessor == null) {
229         // codeStream.getfield(this.codegenBinding);
230         // } else {
231         // codeStream.invokestatic(syntheticReadAccessor);
232         // }
233         // }
234         // int operationTypeID;
235         // if ((operationTypeID = implicitConversion >> 4) == T_String) {
236         // codeStream.generateStringAppend(currentScope, null, expression);
237         // } else {
238         // // promote the array reference to the suitable operation type
239         // codeStream.generateImplicitConversion(implicitConversion);
240         // // generate the increment value (will by itself be promoted to the
241         // operation value)
242         // if (expression == IntLiteral.One) { // prefix operation
243         // codeStream.generateConstant(expression.constant, implicitConversion);
244         // } else {
245         // expression.generateCode(currentScope, codeStream, true);
246         // }
247         // // perform the operation
248         // codeStream.sendOperator(operator, operationTypeID);
249         // // cast the value back to the array reference type
250         // codeStream.generateImplicitConversion(assignmentImplicitConversion);
251         // }
252         // fieldStore(
253         // codeStream,
254         // this.codegenBinding,
255         // syntheticWriteAccessor,
256         // valueRequired);
257         // }
258         //
259         // public void generatePostIncrement(
260         // BlockScope currentScope,
261         // CodeStream codeStream,
262         // CompoundAssignment postIncrement,
263         // boolean valueRequired) {
264         //
265         // boolean isStatic;
266         // receiver.generateCode(
267         // currentScope,
268         // codeStream,
269         // !(isStatic = this.codegenBinding.isStatic()));
270         // if (isStatic) {
271         // if (syntheticReadAccessor == null) {
272         // codeStream.getstatic(this.codegenBinding);
273         // } else {
274         // codeStream.invokestatic(syntheticReadAccessor);
275         // }
276         // } else {
277         // codeStream.dup();
278         // if (syntheticReadAccessor == null) {
279         // codeStream.getfield(this.codegenBinding);
280         // } else {
281         // codeStream.invokestatic(syntheticReadAccessor);
282         // }
283         // }
284         // if (valueRequired) {
285         // if (isStatic) {
286         // if ((this.codegenBinding.type == LongBinding)
287         // || (this.codegenBinding.type == DoubleBinding)) {
288         // codeStream.dup2();
289         // } else {
290         // codeStream.dup();
291         // }
292         // } else { // Stack: [owner][old field value] ---> [old field
293         // value][owner][old field value]
294         // if ((this.codegenBinding.type == LongBinding)
295         // || (this.codegenBinding.type == DoubleBinding)) {
296         // codeStream.dup2_x1();
297         // } else {
298         // codeStream.dup_x1();
299         // }
300         // }
301         // }
302         // codeStream.generateConstant(
303         // postIncrement.expression.constant,
304         // implicitConversion);
305         // codeStream.sendOperator(postIncrement.operator,
306         // this.codegenBinding.type.id);
307         // codeStream.generateImplicitConversion(
308         // postIncrement.assignmentImplicitConversion);
309         // fieldStore(codeStream, this.codegenBinding, syntheticWriteAccessor,
310         // false);
311         // }
312         public static final Constant getConstantFor(FieldBinding binding,
313                         Reference reference, boolean isImplicit, Scope referenceScope) {
314
315                 // propagation of the constant.
316
317                 // ref can be a FieldReference, a SingleNameReference or a
318                 // QualifiedNameReference
319                 // indexInQualification may have a value greater than zero only for
320                 // QualifiednameReference
321                 // if ref==null then indexInQualification==0 AND implicitReceiver ==
322                 // false. This case is a
323                 // degenerated case where a fake reference field (null)
324                 // is associted to a real FieldBinding in order
325                 // to allow its constant computation using the regular path (in other
326                 // words, find the fieldDeclaration
327                 // and proceed to its type resolution). As implicitReceiver is false, no
328                 // error reporting
329                 // against ref will be used ==> no nullPointerException risk ....
330
331                 // special treatment for langage-built-in field (their declaring class
332                 // is null)
333                 if (binding.declaringClass == null) {
334                         // currently only one field "length" : the constant computation is
335                         // never done
336                         return NotAConstant;
337                 }
338                 if (!binding.isFinal()) {
339                         return binding.constant = NotAConstant;
340                 }
341                 if (binding.constant != null) {
342                         if (isImplicit
343                                         || (reference instanceof QualifiedNameReference && binding == ((QualifiedNameReference) reference).binding)) {
344                                 return binding.constant;
345                         }
346                         return NotAConstant;
347                 }
348
349                 // The field has not been yet type checked.
350                 // It also means that the field is not coming from a class that
351                 // has already been compiled. It can only be from a class within
352                 // compilation units to process. Thus the field is NOT from a
353                 // BinaryTypeBinbing
354
355                 SourceTypeBinding typeBinding = (SourceTypeBinding) binding.declaringClass;
356                 TypeDeclaration typeDecl = typeBinding.scope.referenceContext;
357                 FieldDeclaration fieldDecl = typeDecl.declarationOf(binding);
358
359                 fieldDecl.resolve(binding.isStatic() // side effect on binding
360                 ? typeDecl.staticInitializerScope
361                                 : typeDecl.initializerScope);
362
363                 if (isImplicit
364                                 || (reference instanceof QualifiedNameReference && binding == ((QualifiedNameReference) reference).binding)) {
365                         return binding.constant;
366                 }
367                 return NotAConstant;
368         }
369
370         public boolean isSuperAccess() {
371
372                 return receiver.isSuper();
373         }
374
375         public boolean isTypeAccess() {
376
377                 return receiver != null && receiver.isTypeReference();
378         }
379
380         /*
381          * No need to emulate access to protected fields since not implicitly
382          * accessed
383          */
384         public void manageSyntheticReadAccessIfNecessary(BlockScope currentScope) {
385
386                 if (binding.isPrivate()) {
387                         if ((currentScope.enclosingSourceType() != binding.declaringClass)
388                                         && (binding.constant == NotAConstant)) {
389                                 syntheticReadAccessor = ((SourceTypeBinding) binding.declaringClass)
390                                                 .addSyntheticMethod(binding, true);
391                                 currentScope.problemReporter().needToEmulateFieldReadAccess(
392                                                 binding, this);
393                                 return;
394                         }
395
396                 } else if (receiver instanceof QualifiedSuperReference) { // qualified
397                                                                                                                                         // super
398
399                         // qualified super need emulation always
400                         SourceTypeBinding destinationType = (SourceTypeBinding) (((QualifiedSuperReference) receiver).currentCompatibleType);
401                         syntheticReadAccessor = destinationType.addSyntheticMethod(binding,
402                                         true);
403                         currentScope.problemReporter().needToEmulateFieldReadAccess(
404                                         binding, this);
405                         return;
406
407                 } else if (binding.isProtected()) {
408
409                         SourceTypeBinding enclosingSourceType;
410                         if (((bits & DepthMASK) != 0)
411                                         && binding.declaringClass.getPackage() != (enclosingSourceType = currentScope
412                                                         .enclosingSourceType()).getPackage()) {
413
414                                 SourceTypeBinding currentCompatibleType = (SourceTypeBinding) enclosingSourceType
415                                                 .enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
416                                 syntheticReadAccessor = currentCompatibleType
417                                                 .addSyntheticMethod(binding, true);
418                                 currentScope.problemReporter().needToEmulateFieldReadAccess(
419                                                 binding, this);
420                                 return;
421                         }
422                 }
423                 // if the binding declaring class is not visible, need special action
424                 // for runtime compatibility on 1.2 VMs : change the declaring class of
425                 // the binding
426                 // NOTE: from target 1.2 on, field's declaring class is touched if any
427                 // different from receiver type
428                 // if (binding.declaringClass != this.receiverType
429                 // && !this.receiverType.isArrayType()
430                 // && binding.declaringClass != null // array.length
431                 // && binding.constant == NotAConstant
432                 // && ((currentScope.environment().options.targetJDK >=
433                 // CompilerOptions.JDK1_2
434                 // && binding.declaringClass.id != T_Object)
435                 // //no change for Object fields (in case there was)
436                 // || !binding.declaringClass.canBeSeenBy(currentScope))) {
437                 // this.codegenBinding =
438                 // currentScope.enclosingSourceType().getUpdatedFieldBinding(
439                 // binding,
440                 // (ReferenceBinding) this.receiverType);
441                 // }
442         }
443
444         /*
445          * No need to emulate access to protected fields since not implicitly
446          * accessed
447          */
448         public void manageSyntheticWriteAccessIfNecessary(BlockScope currentScope) {
449
450                 if (binding.isPrivate()) {
451                         if (currentScope.enclosingSourceType() != binding.declaringClass) {
452                                 syntheticWriteAccessor = ((SourceTypeBinding) binding.declaringClass)
453                                                 .addSyntheticMethod(binding, false);
454                                 currentScope.problemReporter().needToEmulateFieldWriteAccess(
455                                                 binding, this);
456                                 return;
457                         }
458
459                 } else if (receiver instanceof QualifiedSuperReference) { // qualified
460                                                                                                                                         // super
461
462                         // qualified super need emulation always
463                         SourceTypeBinding destinationType = (SourceTypeBinding) (((QualifiedSuperReference) receiver).currentCompatibleType);
464                         syntheticWriteAccessor = destinationType.addSyntheticMethod(
465                                         binding, false);
466                         currentScope.problemReporter().needToEmulateFieldWriteAccess(
467                                         binding, this);
468                         return;
469
470                 } else if (binding.isProtected()) {
471
472                         SourceTypeBinding enclosingSourceType;
473                         if (((bits & DepthMASK) != 0)
474                                         && binding.declaringClass.getPackage() != (enclosingSourceType = currentScope
475                                                         .enclosingSourceType()).getPackage()) {
476
477                                 SourceTypeBinding currentCompatibleType = (SourceTypeBinding) enclosingSourceType
478                                                 .enclosingTypeAt((bits & DepthMASK) >> DepthSHIFT);
479                                 syntheticWriteAccessor = currentCompatibleType
480                                                 .addSyntheticMethod(binding, false);
481                                 currentScope.problemReporter().needToEmulateFieldWriteAccess(
482                                                 binding, this);
483                                 return;
484                         }
485                 }
486                 // if the binding declaring class is not visible, need special action
487                 // for runtime compatibility on 1.2 VMs : change the declaring class of
488                 // the binding
489                 // NOTE: from target 1.2 on, field's declaring class is touched if any
490                 // different from receiver type
491                 // if (binding.declaringClass != this.receiverType
492                 // && !this.receiverType.isArrayType()
493                 // && binding.declaringClass != null // array.length
494                 // && binding.constant == NotAConstant
495                 // && ((currentScope.environment().options.targetJDK >=
496                 // CompilerOptions.JDK1_2
497                 // && binding.declaringClass.id != T_Object)
498                 // //no change for Object fields (in case there was)
499                 // || !binding.declaringClass.canBeSeenBy(currentScope))) {
500                 // this.codegenBinding =
501                 // currentScope.enclosingSourceType().getUpdatedFieldBinding(
502                 // binding,
503                 // (ReferenceBinding) this.receiverType);
504                 // }
505         }
506
507         public TypeBinding resolveType(BlockScope scope) {
508
509                 // Answer the signature type of the field.
510                 // constants are propaged when the field is final
511                 // and initialized with a (compile time) constant
512
513                 // regular receiver reference
514                 this.receiverType = receiver.resolveType(scope);
515                 if (this.receiverType == null) {
516                         constant = NotAConstant;
517                         return null;
518                 }
519                 // the case receiverType.isArrayType and token = 'length' is handled by
520                 // the scope API
521                 this.codegenBinding = this.binding = scope.getField(this.receiverType,
522                                 token, this);
523                 if (!binding.isValidBinding()) {
524                         constant = NotAConstant;
525                         scope.problemReporter().invalidField(this, this.receiverType);
526                         return null;
527                 }
528
529                 if (isFieldUseDeprecated(binding, scope))
530                         scope.problemReporter().deprecatedField(binding, this);
531
532                 boolean isImplicitThisRcv = receiver.isImplicitThis();
533                 constant = FieldReference.getConstantFor(binding, this,
534                                 isImplicitThisRcv, scope);
535                 if (!isImplicitThisRcv) {
536                         constant = NotAConstant;
537                 }
538                 if (binding.isStatic()) {
539                         // static field accessed through receiver? legal but unoptimal
540                         // (optional warning)
541                         if (!(isImplicitThisRcv || receiver.isSuper() || (receiver instanceof NameReference && (((NameReference) receiver).bits & BindingIds.TYPE) != 0))) {
542                                 scope.problemReporter().unnecessaryReceiverForStaticField(this,
543                                                 binding);
544                         }
545                 }
546                 return this.resolvedType = binding.type;
547         }
548
549         public void setActualReceiverType(ReferenceBinding receiverType) {
550                 // ignored
551         }
552
553         public void setDepth(int depth) {
554
555                 bits &= ~DepthMASK; // flush previous depth if any
556                 if (depth > 0) {
557                         bits |= (depth & 0xFF) << DepthSHIFT; // encoded on 8 bits
558                 }
559         }
560
561         public void setFieldIndex(int index) {
562                 // ignored
563         }
564
565         public StringBuffer printExpression(int indent, StringBuffer output) {
566
567                 return receiver.printExpression(0, output).append('.').append(token);
568         }
569
570         public String toStringExpression() {
571
572                 return receiver.toString() + "." //$NON-NLS-1$
573                                 + new String(token);
574         }
575
576         public void traverse(ASTVisitor visitor, BlockScope scope) {
577
578                 if (visitor.visit(this, scope)) {
579                         receiver.traverse(visitor, scope);
580                 }
581                 visitor.endVisit(this, scope);
582         }
583 }