1) Fixed issue #828: Non initialized variable warnings doesn't work with variables...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / ASTNode.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.impl.Constant;
15 import net.sourceforge.phpdt.internal.compiler.lookup.ArrayBinding;
16 import net.sourceforge.phpdt.internal.compiler.lookup.BaseTypes;
17 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
18 import net.sourceforge.phpdt.internal.compiler.lookup.CompilerModifiers;
19 import net.sourceforge.phpdt.internal.compiler.lookup.FieldBinding;
20 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
21 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
22 import net.sourceforge.phpdt.internal.compiler.lookup.Scope;
23 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
24 import net.sourceforge.phpdt.internal.compiler.lookup.TypeConstants;
25 import net.sourceforge.phpdt.internal.compiler.lookup.TypeIds;
26
27 public abstract class ASTNode implements BaseTypes, CompilerModifiers,
28                 TypeConstants, TypeIds {
29
30         public int sourceStart, sourceEnd;
31
32         // some global provision for the hierarchy
33         public final static Constant NotAConstant = Constant.NotAConstant;
34
35         // storage for internal flags (32 bits) BIT USAGE
36         public final static int Bit1 = 0x1; // return type (operators) | name
37                                                                                 // reference kind (name ref) | add
38                                                                                 // assertion (type decl)
39
40         public final static int Bit2 = 0x2; // return type (operators) | name
41                                                                                 // reference kind (name ref) | has local
42                                                                                 // type (type, method, field decl)
43
44         public final static int Bit3 = 0x4; // return type (operators) | name
45                                                                                 // reference kind (name ref) | implicit
46                                                                                 // this (this ref)
47
48         public final static int Bit4 = 0x8; // return type (operators) | first
49                                                                                 // assignment to local (local decl)
50
51         public final static int Bit5 = 0x10; // value for return (binary
52                                                                                         // expression) |
53
54         public final static int Bit6 = 0x20; // depth (name ref, msg) | only
55                                                                                         // value required (binary
56                                                                                         // expression)
57
58         public final static int Bit7 = 0x40; // depth (name ref, msg) | operator
59                                                                                         // (operators)
60
61         public final static int Bit8 = 0x80; // depth (name ref, msg) | operator
62                                                                                         // (operators)
63
64         public final static int Bit9 = 0x100; // depth (name ref, msg) | operator
65                                                                                         // (operators)
66
67         public final static int Bit10 = 0x200; // depth (name ref, msg) | operator
68                                                                                         // (operators)
69
70         public final static int Bit11 = 0x400; // depth (name ref, msg) | operator
71                                                                                         // (operators)
72
73         public final static int Bit12 = 0x800; // depth (name ref, msg) | operator
74                                                                                         // (operators)
75
76         public final static int Bit13 = 0x1000; // depth (name ref, msg)
77
78         public final static int Bit14 = 0x2000; // assigned (reference lhs)
79
80         public final static int Bit15 = 0x4000;
81
82         public final static int Bit16 = 0x8000;
83
84         public final static int Bit17 = 0x10000;
85
86         public final static int Bit18 = 0x20000;
87
88         public final static int Bit19 = 0x40000;
89
90         public final static int Bit20 = 0x80000;
91
92         public final static int Bit21 = 0x100000;
93
94         public final static int Bit22 = 0x200000; // parenthesis count
95                                                                                                 // (expression)
96
97         public final static int Bit23 = 0x400000; // parenthesis count
98                                                                                                 // (expression)
99
100         public final static int Bit24 = 0x800000; // parenthesis count
101                                                                                                 // (expression)
102
103         public final static int Bit25 = 0x1000000; // parenthesis count
104                                                                                                 // (expression)
105
106         public final static int Bit26 = 0x2000000; // parenthesis count
107                                                                                                 // (expression)
108
109         public final static int Bit27 = 0x4000000; // parenthesis count
110                                                                                                 // (expression)
111
112         public final static int Bit28 = 0x8000000; // parenthesis count
113                                                                                                 // (expression)
114
115         public final static int Bit29 = 0x10000000; // parenthesis count
116                                                                                                 // (expression)
117
118         public final static int Bit30 = 0x20000000; // assignment with no effect
119                                                                                                 // (assignment)
120
121         public final static int Bit31 = 0x40000000; // local declaration reachable
122                                                                                                 // (local decl)
123
124         public final static int Bit32 = 0x80000000; // reachable (statement)
125
126         public int bits = IsReachableMASK; // reachable by default
127
128         // for operators
129         public static final int ReturnTypeIDMASK = Bit1 | Bit2 | Bit3 | Bit4;
130
131         public static final int OperatorSHIFT = 6; // Bit7 -> Bit12
132
133         public static final int OperatorMASK = Bit7 | Bit8 | Bit9 | Bit10 | Bit11
134                         | Bit12; // 6 bits for operator ID
135
136         // for binary expressions
137         public static final int ValueForReturnMASK = Bit5;
138
139         public static final int OnlyValueRequiredMASK = Bit6;
140
141         // for name references
142         public static final int RestrictiveFlagMASK = Bit1 | Bit2 | Bit3;
143
144         public static final int FirstAssignmentToLocalMASK = Bit4;
145
146         // for this reference
147         public static final int IsImplicitThisMask = Bit3;
148
149         // for single name references
150         public static final int DepthSHIFT = 5; // Bit6 -> Bit13
151
152         public static final int DepthMASK = Bit6 | Bit7 | Bit8 | Bit9 | Bit10
153                         | Bit11 | Bit12 | Bit13; // 8 bits for actual depth value (max.
154                                                                                 // 255)
155
156         // for statements
157         public static final int IsReachableMASK = Bit32;
158
159         public static final int IsLocalDeclarationReachableMASK = Bit31;
160
161         // for type declaration
162         public static final int AddAssertionMASK = Bit1;
163
164         public static final int IsMemberTypeMASK = Bit11; // local member do not
165                                                                                                                 // know it is local at
166                                                                                                                 // parse time (need to
167                                                                                                                 // look at binding)
168
169         // for type, method and field declarations
170         public static final int HasLocalTypeMASK = Bit2; // cannot conflict with
171                                                                                                                 // AddAssertionMASK
172
173         // for expression
174         public static final int ParenthesizedSHIFT = 21; // Bit22 -> Bit29
175
176         public static final int ParenthesizedMASK = Bit22 | Bit23 | Bit24 | Bit25
177                         | Bit26 | Bit27 | Bit28 | Bit29; // 8 bits for parenthesis count
178                                                                                                 // value (max. 255)
179
180         // for assignment
181         public static final int IsAssignmentWithNoEffectMASK = Bit30;
182
183         // for references on lhs of assignment (set only for true assignments, as
184         // opposed to compound ones)
185         public static final int IsStrictlyAssignedMASK = Bit14;
186
187         public static final int IsCompoundAssignedMASK = Bit17; // set only for
188                                                                                                                         // compound
189                                                                                                                         // assignments, as
190                                                                                                                         // opposed to other
191                                                                                                                         // ones
192
193         // for empty statement
194         public static final int IsUsefulEmptyStatementMASK = Bit1;
195
196         // for block and method declaration
197         public static final int UndocumentedEmptyBlockMASK = Bit4;
198
199         // for compilation unit
200         public static final int HasAllMethodBodies = Bit5;
201
202         // for references in Javadoc comments
203         public static final int InsideJavadoc = Bit16;
204
205         // for if statement
206         public static final int IsElseIfStatement = Bit30;
207
208         public ASTNode() {
209
210                 super();
211         }
212
213         public boolean cannotReturn() {
214                 return false;
215         }
216
217         public ASTNode concreteStatement() {
218                 return this;
219         }
220
221         /*
222          * Answer true if the field use is considered deprecated. An access in the
223          * same compilation unit is allowed.
224          */
225         public final boolean isFieldUseDeprecated(FieldBinding field, Scope scope) {
226
227                 if (field.isPrivate() && !scope.isDefinedInField(field)) {
228                         // ignore cases where field is used from within inside itself
229                         field.modifiers |= AccPrivateUsed;
230                 }
231
232                 if (!field.isViewedAsDeprecated())
233                         return false;
234
235                 // inside same unit - no report
236                 if (scope.isDefinedInSameUnit(field.declaringClass))
237                         return false;
238
239                 // if context is deprecated, may avoid reporting
240                 // if
241                 // (!scope.environment().options.reportDeprecationInsideDeprecatedCode
242                 // && scope.isInsideDeprecatedCode()) return false;
243                 return true;
244         }
245
246         public boolean isImplicitThis() {
247
248                 return false;
249         }
250
251         /*
252          * Answer true if the method use is considered deprecated. An access in the
253          * same compilation unit is allowed.
254          */
255         public final boolean isMethodUseDeprecated(MethodBinding method, Scope scope) {
256
257                 if (method.isPrivate() && !scope.isDefinedInMethod(method)) {
258                         // ignore cases where method is used from within inside itself (e.g.
259                         // direct recursions)
260                         method.modifiers |= AccPrivateUsed;
261                 }
262
263                 if (!method.isViewedAsDeprecated())
264                         return false;
265
266                 // inside same unit - no report
267                 if (scope.isDefinedInSameUnit(method.declaringClass))
268                         return false;
269
270                 // if context is deprecated, may avoid reporting
271                 // if
272                 // (!scope.environment().options.reportDeprecationInsideDeprecatedCode
273                 // && scope.isInsideDeprecatedCode()) return false;
274                 return true;
275         }
276
277         public boolean isSuper() {
278
279                 return false;
280         }
281
282         public boolean isThis() {
283
284                 return false;
285         }
286
287         /*
288          * Answer true if the type use is considered deprecated. An access in the
289          * same compilation unit is allowed.
290          */
291         public final boolean isTypeUseDeprecated(TypeBinding type, Scope scope) {
292
293                 if (type.isArrayType())
294                         type = ((ArrayBinding) type).leafComponentType;
295                 if (type.isBaseType())
296                         return false;
297
298                 ReferenceBinding refType = (ReferenceBinding) type;
299
300                 if (refType.isPrivate() && !scope.isDefinedInType(refType)) {
301                         // ignore cases where type is used from within inside itself
302                         refType.modifiers |= AccPrivateUsed;
303                 }
304
305                 if (!refType.isViewedAsDeprecated())
306                         return false;
307
308                 // inside same unit - no report
309                 if (scope.isDefinedInSameUnit(refType))
310                         return false;
311
312                 // if context is deprecated, may avoid reporting
313                 // if
314                 // (!scope.environment().options.reportDeprecationInsideDeprecatedCode
315                 // && scope.isInsideDeprecatedCode()) return false;
316                 return true;
317         }
318
319         public static String modifiersString(int modifiers) {
320
321                 String s = ""; //$NON-NLS-1$
322                 if ((modifiers & AccPublic) != 0)
323                         s = s + "public "; //$NON-NLS-1$
324                 if ((modifiers & AccPrivate) != 0)
325                         s = s + "private "; //$NON-NLS-1$
326                 if ((modifiers & AccProtected) != 0)
327                         s = s + "protected "; //$NON-NLS-1$
328                 if ((modifiers & AccStatic) != 0)
329                         s = s + "static "; //$NON-NLS-1$
330                 if ((modifiers & AccFinal) != 0)
331                         s = s + "final "; //$NON-NLS-1$
332                         // if ((modifiers & AccSynchronized) != 0)
333                         // s = s + "synchronized "; //$NON-NLS-1$
334                         // if ((modifiers & AccVolatile) != 0)
335                         // s = s + "volatile "; //$NON-NLS-1$
336                         // if ((modifiers & AccTransient) != 0)
337                         // s = s + "transient "; //$NON-NLS-1$
338                         // if ((modifiers & AccNative) != 0)
339                         // s = s + "native "; //$NON-NLS-1$
340                 if ((modifiers & AccAbstract) != 0)
341                         s = s + "abstract "; //$NON-NLS-1$
342                 return s;
343         }
344
345         public abstract StringBuffer print(int indent, StringBuffer output);
346
347         public static StringBuffer printIndent(int indent, StringBuffer output) {
348
349                 for (int i = indent; i > 0; i--)
350                         output.append("  "); //$NON-NLS-1$
351                 return output;
352         }
353
354         public static StringBuffer printModifiers(int modifiers, StringBuffer output) {
355
356                 if ((modifiers & AccPublic) != 0)
357                         output.append("public "); //$NON-NLS-1$
358                 if ((modifiers & AccPrivate) != 0)
359                         output.append("private "); //$NON-NLS-1$
360                 if ((modifiers & AccProtected) != 0)
361                         output.append("protected "); //$NON-NLS-1$
362                 if ((modifiers & AccStatic) != 0)
363                         output.append("static "); //$NON-NLS-1$
364                 if ((modifiers & AccFinal) != 0)
365                         output.append("final "); //$NON-NLS-1$
366                         // if ((modifiers & AccSynchronized) != 0)
367                         // output.append("synchronized "); //$NON-NLS-1$
368                         // if ((modifiers & AccVolatile) != 0)
369                         // output.append("volatile "); //$NON-NLS-1$
370                         // if ((modifiers & AccTransient) != 0)
371                         // output.append("transient "); //$NON-NLS-1$
372                         // if ((modifiers & AccNative) != 0)
373                         // output.append("native "); //$NON-NLS-1$
374                 if ((modifiers & AccAbstract) != 0)
375                         output.append("abstract "); //$NON-NLS-1$
376                 return output;
377         }
378
379         /**
380          * @deprecated - use field instead
381          */
382         public int sourceEnd() {
383                 return sourceEnd;
384         }
385
386         /**
387          * @deprecated - use field instead
388          */
389         public int sourceStart() {
390                 return sourceStart;
391         }
392
393         public static String tabString(int tab) {
394
395                 String s = ""; //$NON-NLS-1$
396                 for (int i = tab; i > 0; i--)
397                         s = s + "  "; //$NON-NLS-1$
398                 return s;
399         }
400
401         public String toString() {
402
403                 return toString(0);
404         }
405
406         public String toString(int tab) {
407
408                 return "****" + super.toString() + "****"; //$NON-NLS-2$ //$NON-NLS-1$
409         }
410
411         public void traverse(ASTVisitor visitor, BlockScope scope) {
412         }
413 }