Refactory: Remove UI from core plugin.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / TryStatement.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.codegen.Label;
15 import net.sourceforge.phpdt.internal.compiler.flow.ExceptionHandlingFlowContext;
16 import net.sourceforge.phpdt.internal.compiler.flow.FinallyFlowContext;
17 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
18 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
19 import net.sourceforge.phpdt.internal.compiler.flow.InsideSubRoutineFlowContext;
20 import net.sourceforge.phpdt.internal.compiler.flow.UnconditionalFlowInfo;
21 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
22 import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
23 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
24 import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
25 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
26 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
27
28 public class TryStatement extends Statement {
29
30         public Block tryBlock;
31
32         public Block[] catchBlocks;
33
34         public Argument[] catchArguments;
35
36         public Block finallyBlock;
37
38         BlockScope scope;
39
40         public boolean subRoutineCannotReturn = true;
41
42         public UnconditionalFlowInfo subRoutineInits;
43
44         // should rename into subRoutineComplete to be set to false by default
45
46         ReferenceBinding[] caughtExceptionTypes;
47
48         boolean tryBlockExit;
49
50         boolean[] catchExits;
51
52         public int[] preserveExceptionHandler;
53
54         Label subRoutineStartLabel;
55
56         public LocalVariableBinding anyExceptionVariable, returnAddressVariable,
57                         secretReturnValue;
58
59         public final static char[] SecretReturnName = " returnAddress".toCharArray(); //$NON-NLS-1$
60
61         public final static char[] SecretAnyHandlerName = " anyExceptionHandler".toCharArray(); //$NON-NLS-1$
62
63         public static final char[] SecretLocalDeclarationName = " returnValue".toCharArray(); //$NON-NLS-1$
64
65         // for local variables table attributes
66         int preTryInitStateIndex = -1;
67
68         int mergedInitStateIndex = -1;
69
70         public FlowInfo analyseCode(BlockScope currentScope,
71                         FlowContext flowContext, FlowInfo flowInfo) {
72
73                 // Consider the try block and catch block so as to compute the
74                 // intersection of initializations and
75                 // the minimum exit relative depth amongst all of them. Then consider
76                 // the subroutine, and append its
77                 // initialization to the try/catch ones, if the subroutine completes
78                 // normally. If the subroutine does not
79                 // complete, then only keep this result for the rest of the analysis
80
81                 // process the finally block (subroutine) - create a context for the
82                 // subroutine
83
84                 preTryInitStateIndex = currentScope.methodScope()
85                                 .recordInitializationStates(flowInfo);
86
87                 if (anyExceptionVariable != null) {
88                         anyExceptionVariable.useFlag = LocalVariableBinding.USED;
89                 }
90                 if (returnAddressVariable != null) {
91                         returnAddressVariable.useFlag = LocalVariableBinding.USED;
92                 }
93                 InsideSubRoutineFlowContext insideSubContext;
94                 FinallyFlowContext finallyContext;
95                 UnconditionalFlowInfo subInfo;
96                 if (subRoutineStartLabel == null) {
97                         // no finally block
98                         insideSubContext = null;
99                         finallyContext = null;
100                         subInfo = null;
101                 } else {
102                         // analyse finally block first
103                         insideSubContext = new InsideSubRoutineFlowContext(flowContext,
104                                         this);
105                         subInfo = finallyBlock.analyseCode(
106                                         currentScope,
107                                         finallyContext = new FinallyFlowContext(flowContext,
108                                                         finallyBlock), flowInfo.copy())
109                                         .unconditionalInits();
110                         if (subInfo.isReachable()) {
111                                 subRoutineCannotReturn = false;
112                         }
113                         this.subRoutineInits = subInfo;
114                 }
115                 // process the try block in a context handling the local exceptions.
116                 ExceptionHandlingFlowContext handlingContext = new ExceptionHandlingFlowContext(
117                                 insideSubContext == null ? flowContext : insideSubContext,
118                                 tryBlock, caughtExceptionTypes, scope, flowInfo
119                                                 .unconditionalInits());
120
121                 FlowInfo tryInfo;
122                 if (tryBlock.statements == null) {
123                         tryInfo = flowInfo;
124                         tryBlockExit = false;
125                 } else {
126                         tryInfo = tryBlock.analyseCode(currentScope, handlingContext,
127                                         flowInfo.copy());
128                         tryBlockExit = !tryInfo.isReachable();
129                 }
130
131                 // check unreachable catch blocks
132                 // handlingContext.complainIfUnusedExceptionHandlers(catchBlocks, scope,
133                 // this);
134
135                 // process the catch blocks - computing the minimal exit depth amongst
136                 // try/catch
137                 if (catchArguments != null) {
138                         int catchCount;
139                         catchExits = new boolean[catchCount = catchBlocks.length];
140                         for (int i = 0; i < catchCount; i++) {
141                                 // keep track of the inits that could potentially have led to
142                                 // this exception handler (for final assignments diagnosis)
143                                 FlowInfo catchInfo = flowInfo.copy().unconditionalInits()
144                                                 .addPotentialInitializationsFrom(
145                                                                 handlingContext.initsOnException(
146                                                                                 caughtExceptionTypes[i])
147                                                                                 .unconditionalInits())
148                                                 .addPotentialInitializationsFrom(
149                                                                 tryInfo.unconditionalInits())
150                                                 .addPotentialInitializationsFrom(
151                                                                 handlingContext.initsOnReturn);
152
153                                 // catch var is always set
154                                 catchInfo.markAsDefinitelyAssigned(catchArguments[i].binding);
155                                 /*
156                                  * "If we are about to consider an unchecked exception handler,
157                                  * potential inits may have occured inside the try block that
158                                  * need to be detected , e.g. try { x = 1; throwSomething();}
159                                  * catch(Exception e){ x = 2} " "(uncheckedExceptionTypes notNil
160                                  * and: [uncheckedExceptionTypes at: index]) ifTrue: [catchInits
161                                  * addPotentialInitializationsFrom: tryInits]."
162                                  */
163                                 // TODO: should only tag as unreachable if the catchblock cannot
164                                 // be reached
165                                 // ??? if
166                                 // (!handlingContext.initsOnException(caughtExceptionTypes[i]).isReachable()){
167                                 if (tryBlock.statements == null) {
168                                         catchInfo.setReachMode(FlowInfo.UNREACHABLE);
169                                 }
170                                 catchInfo = catchBlocks[i].analyseCode(currentScope,
171                                                 insideSubContext == null ? flowContext
172                                                                 : insideSubContext, catchInfo);
173                                 catchExits[i] = !catchInfo.isReachable();
174                                 tryInfo = tryInfo.mergedWith(catchInfo.unconditionalInits());
175                         }
176                 }
177                 if (subRoutineStartLabel == null) {
178                         mergedInitStateIndex = currentScope.methodScope()
179                                         .recordInitializationStates(tryInfo);
180                         return tryInfo;
181                 }
182
183                 // we also need to check potential multiple assignments of final
184                 // variables inside the finally block
185                 // need to include potential inits from returns inside the try/catch
186                 // parts - 1GK2AOF
187                 finallyContext
188                                 .complainOnRedundantFinalAssignments(
189                                                 tryInfo.isReachable() ? (tryInfo
190                                                                 .addPotentialInitializationsFrom(insideSubContext.initsOnReturn))
191                                                                 : insideSubContext.initsOnReturn, currentScope);
192                 if (subInfo == FlowInfo.DEAD_END) {
193                         mergedInitStateIndex = currentScope.methodScope()
194                                         .recordInitializationStates(subInfo);
195                         return subInfo;
196                 } else {
197                         FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);
198                         mergedInitStateIndex = currentScope.methodScope()
199                                         .recordInitializationStates(mergedInfo);
200                         return mergedInfo;
201                 }
202         }
203
204         public boolean cannotReturn() {
205
206                 return subRoutineCannotReturn;
207         }
208
209         /**
210          * Try statement code generation
211          * 
212          */
213         // public void generateCode(BlockScope currentScope, CodeStream codeStream)
214         // {
215         //
216         // if ((bits & IsReachableMASK) == 0) {
217         // return;
218         // }
219         // if (tryBlock.isEmptyBlock()) {
220         // if (subRoutineStartLabel != null) {
221         // // since not passing the finallyScope, the block generation will
222         // exitUserScope(finallyScope)
223         // finallyBlock.generateCode(scope, codeStream);
224         // }
225         // // May loose some local variable initializations : affecting the local
226         // variable attributes
227         // if (mergedInitStateIndex != -1) {
228         // codeStream.removeNotDefinitelyAssignedVariables(
229         // currentScope,
230         // mergedInitStateIndex);
231         // }
232         // // no local bytecode produced so no need for position remembering
233         // return;
234         // }
235         // int pc = codeStream.position;
236         // Label endLabel = new Label(codeStream);
237         // boolean requiresNaturalJsr = false;
238         //
239         // // preparing exception labels
240         // int maxCatches;
241         // ExceptionLabel[] exceptionLabels =
242         // new ExceptionLabel[maxCatches =
243         // catchArguments == null ? 0 : catchArguments.length];
244         // for (int i = 0; i < maxCatches; i++) {
245         // boolean preserveCurrentHandler =
246         // (preserveExceptionHandler[i
247         // / ExceptionHandlingFlowContext.BitCacheSize]
248         // & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
249         // != 0;
250         // if (preserveCurrentHandler) {
251         // exceptionLabels[i] =
252         // new ExceptionLabel(
253         // codeStream,
254         // (ReferenceBinding) catchArguments[i].binding.type);
255         // }
256         // }
257         // ExceptionLabel anyExceptionLabel = null;
258         // if (subRoutineStartLabel != null) {
259         // subRoutineStartLabel.codeStream = codeStream;
260         // anyExceptionLabel = new ExceptionLabel(codeStream, null);
261         // }
262         // // generate the try block
263         // tryBlock.generateCode(scope, codeStream);
264         // boolean tryBlockHasSomeCode = codeStream.position != pc;
265         // // flag telling if some bytecodes were issued inside the try block
266         //
267         // // natural exit: only if necessary
268         // boolean nonReturningSubRoutine =
269         // (subRoutineStartLabel != null) && subRoutineCannotReturn;
270         // if ((!tryBlockExit) && tryBlockHasSomeCode) {
271         // int position = codeStream.position;
272         // if (nonReturningSubRoutine) {
273         // codeStream.goto_(subRoutineStartLabel);
274         // } else {
275         // requiresNaturalJsr = true;
276         // codeStream.goto_(endLabel);
277         // }
278         // codeStream.updateLastRecordedEndPC(position);
279         // //goto is tagged as part of the try block
280         // }
281         // // place end positions of user-defined exception labels
282         // if (tryBlockHasSomeCode) {
283         // for (int i = 0; i < maxCatches; i++) {
284         // boolean preserveCurrentHandler =
285         // (preserveExceptionHandler[i / ExceptionHandlingFlowContext.BitCacheSize]
286         // & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
287         // != 0;
288         // if (preserveCurrentHandler) {
289         // exceptionLabels[i].placeEnd();
290         // }
291         // }
292         // /* generate sequence of handler, all starting by storing the TOS
293         // (exception
294         // thrown) into their own catch variables, the one specified in the source
295         // that must denote the handled exception.
296         // */
297         // if (catchArguments == null) {
298         // if (anyExceptionLabel != null) {
299         // anyExceptionLabel.placeEnd();
300         // }
301         // } else {
302         // for (int i = 0; i < maxCatches; i++) {
303         // boolean preserveCurrentHandler =
304         // (preserveExceptionHandler[i / ExceptionHandlingFlowContext.BitCacheSize]
305         // & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
306         // != 0;
307         // if (preserveCurrentHandler) {
308         // // May loose some local variable initializations : affecting the local
309         // variable attributes
310         // if (preTryInitStateIndex != -1) {
311         // codeStream.removeNotDefinitelyAssignedVariables(
312         // currentScope,
313         // preTryInitStateIndex);
314         // }
315         // exceptionLabels[i].place();
316         // codeStream.incrStackSize(1);
317         // // optimizing the case where the exception variable is not actually used
318         // LocalVariableBinding catchVar;
319         // int varPC = codeStream.position;
320         // if ((catchVar = catchArguments[i].binding).resolvedPosition != -1) {
321         // codeStream.store(catchVar, false);
322         // catchVar.recordInitializationStartPC(codeStream.position);
323         // codeStream.addVisibleLocalVariable(catchVar);
324         // } else {
325         // codeStream.pop();
326         // }
327         // codeStream.recordPositionsFrom(varPC, catchArguments[i].sourceStart);
328         // // Keep track of the pcs at diverging point for computing the local
329         // attribute
330         // // since not passing the catchScope, the block generation will
331         // exitUserScope(catchScope)
332         // catchBlocks[i].generateCode(scope, codeStream);
333         // }
334         // if (i == maxCatches - 1) {
335         // if (anyExceptionLabel != null) {
336         // anyExceptionLabel.placeEnd();
337         // }
338         // if (subRoutineStartLabel != null) {
339         // if (!catchExits[i] && preserveCurrentHandler) {
340         // requiresNaturalJsr = true;
341         // codeStream.goto_(endLabel);
342         // }
343         // }
344         // } else {
345         // if (!catchExits[i] && preserveCurrentHandler) {
346         // if (nonReturningSubRoutine) {
347         // codeStream.goto_(subRoutineStartLabel);
348         // } else {
349         // requiresNaturalJsr = true;
350         // codeStream.goto_(endLabel);
351         // }
352         // }
353         // }
354         // }
355         // }
356         // // addition of a special handler so as to ensure that any uncaught
357         // exception (or exception thrown
358         // // inside catch blocks) will run the finally block
359         // int finallySequenceStartPC = codeStream.position;
360         // if (subRoutineStartLabel != null) {
361         // // the additional handler is doing: jsr finallyBlock and rethrow
362         // TOS-exception
363         // anyExceptionLabel.place();
364         //
365         // if (preTryInitStateIndex != -1) {
366         // // reset initialization state, as for a normal catch block
367         // codeStream.removeNotDefinitelyAssignedVariables(
368         // currentScope,
369         // preTryInitStateIndex);
370         // }
371         //
372         // codeStream.incrStackSize(1);
373         // if (nonReturningSubRoutine) {
374         // codeStream.pop();
375         // // "if subroutine cannot return, no need to jsr/jump to subroutine since
376         // it will be entered in sequence
377         // } else {
378         // codeStream.store(anyExceptionVariable, false);
379         // codeStream.jsr(subRoutineStartLabel);
380         // codeStream.load(anyExceptionVariable);
381         // codeStream.athrow();
382         // }
383         // }
384         // // end of catch sequence, place label that will correspond to the finally
385         // block beginning, or end of statement
386         // endLabel.place();
387         // if (subRoutineStartLabel != null) {
388         // if (nonReturningSubRoutine) {
389         // requiresNaturalJsr = false;
390         // }
391         // Label veryEndLabel = new Label(codeStream);
392         // if (requiresNaturalJsr) {
393         // codeStream.jsr(subRoutineStartLabel);
394         // codeStream.goto_(veryEndLabel);
395         // }
396         // subRoutineStartLabel.place();
397         // if (!nonReturningSubRoutine) {
398         // codeStream.incrStackSize(1);
399         // codeStream.store(returnAddressVariable, false);
400         // }
401         // codeStream.recordPositionsFrom(
402         // finallySequenceStartPC,
403         // finallyBlock.sourceStart);
404         // // entire sequence for finally is associated to finally block
405         // finallyBlock.generateCode(scope, codeStream);
406         // if (!nonReturningSubRoutine) {
407         // int position = codeStream.position;
408         // codeStream.ret(returnAddressVariable.resolvedPosition);
409         // codeStream.updateLastRecordedEndPC(position);
410         // // the ret bytecode is part of the subroutine
411         // }
412         // if (requiresNaturalJsr) {
413         // veryEndLabel.place();
414         // }
415         // }
416         // } else {
417         // // try block had no effect, only generate the body of the finally block
418         // if any
419         // if (subRoutineStartLabel != null) {
420         // finallyBlock.generateCode(scope, codeStream);
421         // }
422         // }
423         // // May loose some local variable initializations : affecting the local
424         // variable attributes
425         // if (mergedInitStateIndex != -1) {
426         // codeStream.removeNotDefinitelyAssignedVariables(
427         // currentScope,
428         // mergedInitStateIndex);
429         // codeStream.addDefinitelyAssignedVariables(currentScope,
430         // mergedInitStateIndex);
431         // }
432         // codeStream.recordPositionsFrom(pc, this.sourceStart);
433         // }
434         public void resetStateForCodeGeneration() {
435                 if (this.subRoutineStartLabel != null) {
436                         this.subRoutineStartLabel.resetStateForCodeGeneration();
437                 }
438         }
439
440         public StringBuffer printStatement(int indent, StringBuffer output) {
441                 printIndent(indent, output).append("try \n"); //$NON-NLS-1$
442                 tryBlock.printStatement(indent + 1, output); //$NON-NLS-1$
443
444                 // catches
445                 if (catchBlocks != null)
446                         for (int i = 0; i < catchBlocks.length; i++) {
447                                 output.append('\n');
448                                 printIndent(indent, output).append("catch ("); //$NON-NLS-1$
449                                 catchArguments[i].print(0, output).append(") "); //$NON-NLS-1$
450                                 catchBlocks[i].printStatement(indent + 1, output);
451                         }
452                 // finally
453                 if (finallyBlock != null) {
454                         output.append('\n');
455                         printIndent(indent, output).append("finally\n"); //$NON-NLS-1$
456                         finallyBlock.printStatement(indent + 1, output);
457                 }
458
459                 return output;
460         }
461
462         public void resolve(BlockScope upperScope) {
463
464                 // special scope for secret locals optimization.
465                 this.scope = new BlockScope(upperScope);
466
467                 BlockScope tryScope = new BlockScope(scope);
468                 BlockScope finallyScope = null;
469
470                 if (finallyBlock != null && finallyBlock.statements != null) {
471
472                         finallyScope = new BlockScope(scope, false); // don't add it yet
473                                                                                                                         // to parent scope
474
475                         // provision for returning and forcing the finally block to run
476                         MethodScope methodScope = scope.methodScope();
477
478                         // the type does not matter as long as it is not a base type
479                         this.returnAddressVariable = new LocalVariableBinding(
480                                         SecretReturnName, upperScope.getJavaLangObject(),
481                                         AccDefault, false);
482                         finallyScope.addLocalVariable(returnAddressVariable);
483                         this.returnAddressVariable.constant = NotAConstant; // not inlinable
484                         this.subRoutineStartLabel = new Label();
485
486                         this.anyExceptionVariable = new LocalVariableBinding(
487                                         SecretAnyHandlerName, scope.getJavaLangThrowable(),
488                                         AccDefault, false);
489                         finallyScope.addLocalVariable(this.anyExceptionVariable);
490                         this.anyExceptionVariable.constant = NotAConstant; // not inlinable
491
492                         if (!methodScope.isInsideInitializer()) {
493                                 MethodBinding methodBinding = ((AbstractMethodDeclaration) methodScope.referenceContext).binding;
494                                 if (methodBinding != null) {
495                                         TypeBinding methodReturnType = methodBinding.returnType;
496                                         if (methodReturnType.id != T_void) {
497                                                 this.secretReturnValue = new LocalVariableBinding(
498                                                                 SecretLocalDeclarationName, methodReturnType,
499                                                                 AccDefault, false);
500                                                 finallyScope.addLocalVariable(this.secretReturnValue);
501                                                 this.secretReturnValue.constant = NotAConstant; // not
502                                                                                                                                                 // inlinable
503                                         }
504                                 }
505                         }
506                         finallyBlock.resolveUsing(finallyScope);
507                         // force the finally scope to have variable positions shifted after
508                         // its try scope and catch ones
509                         finallyScope.shiftScopes = new BlockScope[catchArguments == null ? 1
510                                         : catchArguments.length + 1];
511                         finallyScope.shiftScopes[0] = tryScope;
512                 }
513                 this.tryBlock.resolveUsing(tryScope);
514
515                 // arguments type are checked against JavaLangThrowable in
516                 // resolveForCatch(..)
517                 if (this.catchBlocks != null) {
518                         int length = this.catchArguments.length;
519                         TypeBinding[] argumentTypes = new TypeBinding[length];
520                         for (int i = 0; i < length; i++) {
521                                 BlockScope catchScope = new BlockScope(scope);
522                                 if (finallyScope != null) {
523                                         finallyScope.shiftScopes[i + 1] = catchScope;
524                                 }
525                                 // side effect on catchScope in resolveForCatch(..)
526                                 if ((argumentTypes[i] = catchArguments[i]
527                                                 .resolveForCatch(catchScope)) == null)
528                                         return;
529                                 catchBlocks[i].resolveUsing(catchScope);
530                         }
531
532                         // Verify that the catch clause are ordered in the right way:
533                         // more specialized first.
534                         this.caughtExceptionTypes = new ReferenceBinding[length];
535                         for (int i = 0; i < length; i++) {
536                                 caughtExceptionTypes[i] = (ReferenceBinding) argumentTypes[i];
537                                 for (int j = 0; j < i; j++) {
538                                         if (caughtExceptionTypes[i]
539                                                         .isCompatibleWith(argumentTypes[j])) {
540                                                 scope.problemReporter()
541                                                                 .wrongSequenceOfExceptionTypesError(this, i, j);
542                                                 // cannot return - since may still proceed if
543                                                 // unreachable code is ignored (21203)
544                                         }
545                                 }
546                         }
547                 } else {
548                         caughtExceptionTypes = new ReferenceBinding[0];
549                 }
550
551                 if (finallyScope != null) {
552                         // add finallyScope as last subscope, so it can be shifted behind
553                         // try/catch subscopes.
554                         // the shifting is necessary to achieve no overlay in between the
555                         // finally scope and its
556                         // sibling in term of local variable positions.
557                         this.scope.addSubscope(finallyScope);
558                 }
559         }
560
561         public String toString(int tab) {
562                 String s = tabString(tab);
563                 // try
564                 s = s + "try "; //$NON-NLS-1$
565                 if (tryBlock == Block.None)
566                         s = s + "{}"; //$NON-NLS-1$
567                 else
568                         s = s + "\n" + tryBlock.toString(tab + 1); //$NON-NLS-1$
569
570                 // catches
571                 if (catchBlocks != null)
572                         for (int i = 0; i < catchBlocks.length; i++)
573                                 s = s + "\n" + tabString(tab) + "catch (" //$NON-NLS-2$ //$NON-NLS-1$
574                                                 + catchArguments[i].toString(0) + ") " //$NON-NLS-1$
575                                                 + catchBlocks[i].toString(tab + 1);
576                 // finally
577                 if (finallyBlock != null) {
578                         if (finallyBlock == Block.None)
579                                 s = s + "\n" + tabString(tab) + "finally {}"; //$NON-NLS-2$ //$NON-NLS-1$
580                         else
581                                 s = s + "\n" + tabString(tab) + "finally\n" + //$NON-NLS-2$ //$NON-NLS-1$
582                                                 finallyBlock.toString(tab + 1);
583                 }
584
585                 return s;
586         }
587
588         public void traverse(ASTVisitor visitor, BlockScope blockScope) {
589
590                 if (visitor.visit(this, blockScope)) {
591                         tryBlock.traverse(visitor, scope);
592                         if (catchArguments != null) {
593                                 for (int i = 0, max = catchBlocks.length; i < max; i++) {
594                                         catchArguments[i].traverse(visitor, scope);
595                                         catchBlocks[i].traverse(visitor, scope);
596                                 }
597                         }
598                         if (finallyBlock != null)
599                                 finallyBlock.traverse(visitor, scope);
600                 }
601                 visitor.endVisit(this, blockScope);
602         }
603 }