A variable description (like PHPFunctionDeclaration)
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / AbstractMethodDeclaration.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.core.compiler.*;
14 import net.sourceforge.phpdt.internal.compiler.*;
15 import net.sourceforge.phpdt.internal.compiler.impl.*;
16 import net.sourceforge.phpdt.internal.compiler.codegen.*;
17 import net.sourceforge.phpdt.internal.compiler.flow.*;
18 import net.sourceforge.phpdt.internal.compiler.lookup.*;
19 import net.sourceforge.phpdt.internal.compiler.problem.*;
20 import net.sourceforge.phpdt.internal.compiler.parser.*;
21
22 public abstract class AbstractMethodDeclaration
23         extends AstNode
24         implements ProblemSeverities, ReferenceContext {
25                 
26         public MethodScope scope;
27         //it is not relevent for constructor but it helps to have the name of the constructor here 
28         //which is always the name of the class.....parsing do extra work to fill it up while it do not have to....
29         public char[] selector;
30         public int declarationSourceStart;
31         public int declarationSourceEnd;
32         public int modifiers;
33         public int modifiersSourceStart;
34         public Argument[] arguments;
35         public TypeReference[] thrownExceptions;
36         public Statement[] statements;
37         public int explicitDeclarations;
38         public MethodBinding binding;
39         public boolean ignoreFurtherInvestigation = false;
40         public boolean needFreeReturn = false;
41
42         public int bodyStart;
43         public int bodyEnd = -1;
44         public CompilationResult compilationResult;
45         
46         AbstractMethodDeclaration(CompilationResult compilationResult){
47                 this.compilationResult = compilationResult;
48         }
49         
50         /*
51          *      We cause the compilation task to abort to a given extent.
52          */
53         public void abort(int abortLevel) {
54
55                 if (scope == null) {
56                         throw new AbortCompilation(); // cannot do better
57                 }
58
59                 CompilationResult compilationResult =
60                         scope.referenceCompilationUnit().compilationResult;
61
62                 switch (abortLevel) {
63                         case AbortCompilation :
64                                 throw new AbortCompilation(compilationResult);
65                         case AbortCompilationUnit :
66                                 throw new AbortCompilationUnit(compilationResult);
67                         case AbortType :
68                                 throw new AbortType(compilationResult);
69                         default :
70                                 throw new AbortMethod(compilationResult);
71                 }
72         }
73
74         public void analyseCode(
75                 ClassScope currentScope,
76                 FlowContext flowContext,
77                 FlowInfo flowInfo) {
78
79                 // starting of the code analysis for methods
80                 if (ignoreFurtherInvestigation)
81                         return;
82                 try {
83                         if (binding == null)
84                                 return;
85                         // may be in a non necessary <clinit> for innerclass with static final constant fields
86                         if (binding.isAbstract() || binding.isNative())
87                                 return;
88
89                         ExceptionHandlingFlowContext methodContext =
90                                 new ExceptionHandlingFlowContext(
91                                         flowContext,
92                                         this,
93                                         binding.thrownExceptions,
94                                         scope,
95                                         FlowInfo.DeadEnd);
96
97                         // propagate to statements
98                         if (statements != null) {
99                                 for (int i = 0, count = statements.length; i < count; i++) {
100                                         Statement stat;
101                                         if (!flowInfo.complainIfUnreachable((stat = statements[i]), scope)) {
102                                                 flowInfo = stat.analyseCode(scope, methodContext, flowInfo);
103                                         }
104                                 }
105                         }
106                         // check for missing returning path
107                         TypeBinding returnType = binding.returnType;
108                         if ((returnType == VoidBinding) || isAbstract()) {
109                                 needFreeReturn =
110                                         !((flowInfo == FlowInfo.DeadEnd) || flowInfo.isFakeReachable());
111                         } else {
112                                 if (flowInfo != FlowInfo.DeadEnd) {
113                                         // special test for empty methods that should return something
114                                         if ((statements == null) && (returnType != VoidBinding)) {
115                                                 scope.problemReporter().shouldReturn(returnType, this);
116                                         } else {
117                                                 scope.problemReporter().shouldReturn(
118                                                         returnType,
119                                                         statements[statements.length - 1]);
120                                         }
121                                 }
122                         }
123                 } catch (AbortMethod e) {
124                         this.ignoreFurtherInvestigation = true;
125                 }
126         }
127
128         /**
129          * Bind and add argument's binding into the scope of the method
130          */
131         public void bindArguments() {
132
133                 if (arguments != null) {
134                         // by default arguments in abstract/native methods are considered to be used (no complaint is expected)
135                         boolean used = binding == null || binding.isAbstract() || binding.isNative();
136
137                         int length = arguments.length;
138                         for (int i = 0; i < length; i++) {
139                                 TypeBinding argType = binding == null ? null : binding.parameters[i];
140                                 arguments[i].bind(scope, argType, used);
141                         }
142                 }
143         }
144
145         /**
146          * Record the thrown exception type bindings in the corresponding type references.
147          */
148         public void bindThrownExceptions() {
149
150                 if (this.thrownExceptions != null
151                         && this.binding != null
152                         && this.binding.thrownExceptions != null) {
153                         int length = this.binding.thrownExceptions.length;
154                         for (int i = 0; i < length; i++) {
155                                 this.thrownExceptions[i].binding = this.binding.thrownExceptions[i];
156                         }
157                 }
158         }
159
160         public CompilationResult compilationResult() {
161                 
162                 return this.compilationResult;
163         }
164         
165         /**
166          * Bytecode generation for a method
167          */
168         public void generateCode(ClassScope classScope, ClassFile classFile) {
169                 
170                 int problemResetPC = 0;
171                 classFile.codeStream.wideMode = false; // reset wideMode to false
172                 if (ignoreFurtherInvestigation) {
173                         // method is known to have errors, dump a problem method
174                         if (this.binding == null)
175                                 return; // handle methods with invalid signature or duplicates
176                         int problemsLength;
177                         IProblem[] problems =
178                                 scope.referenceCompilationUnit().compilationResult.getProblems();
179                         IProblem[] problemsCopy = new IProblem[problemsLength = problems.length];
180                         System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
181                         classFile.addProblemMethod(this, binding, problemsCopy);
182                         return;
183                 }
184                 // regular code generation
185                 try {
186                         problemResetPC = classFile.contentsOffset;
187                         this.generateCode(classFile);
188                 } catch (AbortMethod e) {
189                         // a fatal error was detected during code generation, need to restart code gen if possible
190                         if (e.compilationResult == CodeStream.RESTART_IN_WIDE_MODE) {
191                                 // a branch target required a goto_w, restart code gen in wide mode.
192                                 try {
193                                         this.traverse(new ResetStateForCodeGenerationVisitor(), classScope);
194                                         classFile.contentsOffset = problemResetPC;
195                                         classFile.methodCount--;
196                                         classFile.codeStream.wideMode = true; // request wide mode 
197                                         this.generateCode(classFile); // restart method generation
198                                 } catch (AbortMethod e2) {
199                                         int problemsLength;
200                                         IProblem[] problems =
201                                                 scope.referenceCompilationUnit().compilationResult.getProblems();
202                                         IProblem[] problemsCopy = new IProblem[problemsLength = problems.length];
203                                         System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
204                                         classFile.addProblemMethod(this, binding, problemsCopy, problemResetPC);
205                                 }
206                         } else {
207                                 // produce a problem method accounting for this fatal error
208                                 int problemsLength;
209                                 IProblem[] problems =
210                                         scope.referenceCompilationUnit().compilationResult.getProblems();
211                                 IProblem[] problemsCopy = new IProblem[problemsLength = problems.length];
212                                 System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
213                                 classFile.addProblemMethod(this, binding, problemsCopy, problemResetPC);
214                         }
215                 }
216         }
217
218         private void generateCode(ClassFile classFile) {
219
220                 classFile.generateMethodInfoHeader(binding);
221                 int methodAttributeOffset = classFile.contentsOffset;
222                 int attributeNumber = classFile.generateMethodInfoAttribute(binding);
223                 if ((!binding.isNative()) && (!binding.isAbstract())) {
224                         int codeAttributeOffset = classFile.contentsOffset;
225                         classFile.generateCodeAttributeHeader();
226                         CodeStream codeStream = classFile.codeStream;
227                         codeStream.reset(this, classFile);
228                         // initialize local positions
229                         scope.computeLocalVariablePositions(binding.isStatic() ? 0 : 1, codeStream);
230
231                         // arguments initialization for local variable debug attributes
232                         if (arguments != null) {
233                                 for (int i = 0, max = arguments.length; i < max; i++) {
234                                         LocalVariableBinding argBinding;
235                                         codeStream.addVisibleLocalVariable(argBinding = arguments[i].binding);
236                                         argBinding.recordInitializationStartPC(0);
237                                 }
238                         }
239                         if (statements != null) {
240                                 for (int i = 0, max = statements.length; i < max; i++)
241                                         statements[i].generateCode(scope, codeStream);
242                         }
243                         if (needFreeReturn) {
244                                 codeStream.return_();
245                         }
246                         // local variable attributes
247                         codeStream.exitUserScope(scope);
248                         codeStream.recordPositionsFrom(0, this.bodyEnd);
249                         classFile.completeCodeAttribute(codeAttributeOffset);
250                         attributeNumber++;
251                 }
252                 classFile.completeMethodInfo(methodAttributeOffset, attributeNumber);
253
254                 // if a problem got reported during code gen, then trigger problem method creation
255                 if (ignoreFurtherInvestigation) {
256                         throw new AbortMethod(scope.referenceCompilationUnit().compilationResult);
257                 }
258         }
259
260         public boolean hasErrors() {
261                 return this.ignoreFurtherInvestigation;
262         }
263
264         public boolean isAbstract() {
265
266                 if (binding != null)
267                         return binding.isAbstract();
268                 return (modifiers & AccAbstract) != 0;
269         }
270
271         public boolean isClinit() {
272
273                 return false;
274         }
275
276         public boolean isConstructor() {
277
278                 return false;
279         }
280
281         public boolean isDefaultConstructor() {
282
283                 return false;
284         }
285
286         public boolean isInitializationMethod() {
287
288                 return false;
289         }
290
291         public boolean isNative() {
292
293                 if (binding != null)
294                         return binding.isNative();
295                 return (modifiers & AccNative) != 0;
296         }
297
298         public boolean isStatic() {
299
300                 if (binding != null)
301                         return binding.isStatic();
302                 return (modifiers & AccStatic) != 0;
303         }
304
305         /**
306          * Fill up the method body with statement
307          */
308         public abstract void parseStatements(
309                 Parser parser,
310                 CompilationUnitDeclaration unit);
311
312         public void resolve(ClassScope upperScope) {
313
314                 if (binding == null) {
315                         ignoreFurtherInvestigation = true;
316                 }
317
318                 try {
319                         bindArguments(); 
320                         bindThrownExceptions();
321                         resolveStatements(upperScope);
322                 } catch (AbortMethod e) {       // ========= abort on fatal error =============
323                         this.ignoreFurtherInvestigation = true;
324                 } 
325         }
326
327         public void resolveStatements(ClassScope upperScope) {
328
329                 if (statements != null) {
330                         int i = 0, length = statements.length;
331                         while (i < length)
332                                 statements[i++].resolve(scope);
333                 }
334         }
335
336         public String returnTypeToString(int tab) {
337
338                 return ""; //$NON-NLS-1$
339         }
340
341         public void tagAsHavingErrors() {
342
343                 ignoreFurtherInvestigation = true;
344         }
345
346         public String toString(int tab) {
347
348                 String s = tabString(tab);
349                 if (modifiers != AccDefault) {
350                         s += modifiersString(modifiers);
351                 }
352
353                 s += returnTypeToString(0);
354                 s += new String(selector) + "("; //$NON-NLS-1$
355                 if (arguments != null) {
356                         for (int i = 0; i < arguments.length; i++) {
357                                 s += arguments[i].toString(0);
358                                 if (i != (arguments.length - 1))
359                                         s = s + ", "; //$NON-NLS-1$
360                         };
361                 };
362                 s += ")"; //$NON-NLS-1$
363                 if (thrownExceptions != null) {
364                         s += " throws "; //$NON-NLS-1$
365                         for (int i = 0; i < thrownExceptions.length; i++) {
366                                 s += thrownExceptions[i].toString(0);
367                                 if (i != (thrownExceptions.length - 1))
368                                         s = s + ", "; //$NON-NLS-1$
369                         };
370                 };
371
372                 s += toStringStatements(tab + 1);
373                 return s;
374         }
375
376         public String toStringStatements(int tab) {
377
378                 if (isAbstract() || (this.modifiers & AccSemicolonBody) != 0)
379                         return ";"; //$NON-NLS-1$
380
381                 String s = " {"; //$NON-NLS-1$
382                 if (statements != null) {
383                         for (int i = 0; i < statements.length; i++) {
384                                 s = s + "\n" + statements[i].toString(tab); //$NON-NLS-1$
385                                 if (!(statements[i] instanceof Block)) {
386                                         s += ";"; //$NON-NLS-1$
387                                 }
388                         }
389                 }
390                 s += "\n" + tabString(tab == 0 ? 0 : tab - 1) + "}"; //$NON-NLS-2$ //$NON-NLS-1$
391                 return s;
392         }
393
394         public void traverse(
395                 IAbstractSyntaxTreeVisitor visitor,
396                 ClassScope classScope) {
397         }
398 }