initial quantum version
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / Compiler.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;
12
13 import java.io.PrintWriter;
14 import java.io.StringWriter;
15 import java.util.Map;
16
17 import net.sourceforge.phpdt.core.compiler.IProblem;
18 import net.sourceforge.phpdt.internal.compiler.env.IBinaryType;
19 import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
20 import net.sourceforge.phpdt.internal.compiler.env.INameEnvironment;
21 import net.sourceforge.phpdt.internal.compiler.env.ISourceType;
22 import net.sourceforge.phpdt.internal.compiler.impl.ITypeRequestor;
23 import net.sourceforge.phpdt.internal.compiler.lookup.LookupEnvironment;
24 import net.sourceforge.phpdt.internal.compiler.lookup.PackageBinding;
25 import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
26 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
27 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilationUnit;
28 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
29 import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities;
30 import net.sourceforge.phpdt.internal.compiler.util.Util;
31 import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
32 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
33
34 public class Compiler implements ITypeRequestor, ProblemSeverities {
35         public UnitParser parser;
36         public ICompilerRequestor requestor;
37 //      public CompilerOptions options;
38         public ProblemReporter problemReporter;
39
40         // management of unit to be processed
41         //public CompilationUnitResult currentCompilationUnitResult;
42         public CompilationUnitDeclaration[] unitsToProcess;
43         public int totalUnits; // (totalUnits-1) gives the last unit in unitToProcess
44
45         // name lookup
46         public LookupEnvironment lookupEnvironment;
47
48         // ONCE STABILIZED, THESE SHOULD RETURN TO A FINAL FIELD
49         public static boolean DEBUG = false;
50         public int parseThreshold = -1;
51         // number of initial units parsed at once (-1: none)
52
53         /*
54          * Static requestor reserved to listening compilation results in debug mode,
55          * so as for example to monitor compiler activity independantly from a particular
56          * builder implementation. It is reset at the end of compilation, and should not 
57          * persist any information after having been reset.
58          */
59 //      public static IDebugRequestor DebugRequestor = null;
60
61         /**
62          * Answer a new compiler using the given name environment and compiler options.
63          * The environment and options will be in effect for the lifetime of the compiler.
64          * When the compiler is run, compilation results are sent to the given requestor.
65          *
66          *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
67          *      Environment used by the compiler in order to resolve type and package
68          *      names. The name environment implements the actual connection of the compiler
69          *      to the outside world (e.g. in batch mode the name environment is performing
70          *      pure file accesses, reuse previous build state or connection to repositories).
71          *      Note: the name environment is responsible for implementing the actual classpath
72          *            rules.
73          *
74          *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
75          *      Configurable part for problem handling, allowing the compiler client to
76          *      specify the rules for handling problems (stop on first error or accumulate
77          *      them all) and at the same time perform some actions such as opening a dialog
78          *      in UI when compiling interactively.
79          *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
80          *      
81          *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
82          *      Component which will receive and persist all compilation results and is intended
83          *      to consume them as they are produced. Typically, in a batch compiler, it is 
84          *      responsible for writing out the actual .class files to the file system.
85          *      @see org.eclipse.jdt.internal.compiler.CompilationResult
86          *
87          *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
88          *      Factory used inside the compiler to create problem descriptors. It allows the
89          *      compiler client to supply its own representation of compilation problems in
90          *      order to avoid object conversions. Note that the factory is not supposed
91          *      to accumulate the created problems, the compiler will gather them all and hand
92          *      them back as part of the compilation unit result.
93          */
94         public Compiler(
95                 INameEnvironment environment,
96                 IErrorHandlingPolicy policy,
97 //              Map settings,
98                 final ICompilerRequestor requestor,
99                 IProblemFactory problemFactory) {
100
101                 // create a problem handler given a handling policy
102 //              this.options = new CompilerOptions(settings);
103                 
104                 // wrap requestor in DebugRequestor if one is specified
105 //              if(DebugRequestor == null) {
106                         this.requestor = requestor;
107 //              } else {
108 //                      this.requestor = new ICompilerRequestor(){
109 //                              public void acceptResult(CompilationResult result){
110 //                                      if (DebugRequestor.isActive()){
111 //                                              DebugRequestor.acceptDebugResult(result);
112 //                                      }
113 //                                      requestor.acceptResult(result);
114 //                              }
115 //                      };
116 //              }
117                 this.problemReporter =
118                         new ProblemReporter(policy, problemFactory);//this.options, problemFactory);
119                 this.lookupEnvironment =
120                         new LookupEnvironment(this, problemReporter, environment); //options, problemReporter, environment);
121                 this.parser =
122                         new UnitParser(
123                                 problemReporter); 
124 //                              this.options.parseLiteralExpressionsAsConstants, 
125 //                              options.sourceLevel >= CompilerOptions.JDK1_4);
126         }
127         
128         /**
129          * Answer a new compiler using the given name environment and compiler options.
130          * The environment and options will be in effect for the lifetime of the compiler.
131          * When the compiler is run, compilation results are sent to the given requestor.
132          *
133          *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
134          *      Environment used by the compiler in order to resolve type and package
135          *      names. The name environment implements the actual connection of the compiler
136          *      to the outside world (e.g. in batch mode the name environment is performing
137          *      pure file accesses, reuse previous build state or connection to repositories).
138          *      Note: the name environment is responsible for implementing the actual classpath
139          *            rules.
140          *
141          *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
142          *      Configurable part for problem handling, allowing the compiler client to
143          *      specify the rules for handling problems (stop on first error or accumulate
144          *      them all) and at the same time perform some actions such as opening a dialog
145          *      in UI when compiling interactively.
146          *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
147          *      
148          *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
149          *      Component which will receive and persist all compilation results and is intended
150          *      to consume them as they are produced. Typically, in a batch compiler, it is 
151          *      responsible for writing out the actual .class files to the file system.
152          *      @see org.eclipse.jdt.internal.compiler.CompilationResult
153          *
154          *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
155          *      Factory used inside the compiler to create problem descriptors. It allows the
156          *      compiler client to supply its own representation of compilation problems in
157          *      order to avoid object conversions. Note that the factory is not supposed
158          *      to accumulate the created problems, the compiler will gather them all and hand
159          *      them back as part of the compilation unit result.
160          *      @param parseLiteralExpressionsAsConstants <code>boolean</code>
161          *              This parameter is used to optimize the literals or leave them as they are in the source.
162          *              If you put true, "Hello" + " world" will be converted to "Hello world".
163          */
164         public Compiler(
165                 INameEnvironment environment,
166                 IErrorHandlingPolicy policy,
167 //              Map settings,
168                 final ICompilerRequestor requestor,
169                 IProblemFactory problemFactory,
170                 boolean parseLiteralExpressionsAsConstants) {
171
172                 // create a problem handler given a handling policy
173 //              this.options = new CompilerOptions(settings);
174                 
175                 // wrap requestor in DebugRequestor if one is specified
176 //              if(DebugRequestor == null) {
177                         this.requestor = requestor;
178 //              } else {
179 //                      this.requestor = new ICompilerRequestor(){
180 //                              public void acceptResult(CompilationResult result){
181 //                                      if (DebugRequestor.isActive()){
182 //                                              DebugRequestor.acceptDebugResult(result);
183 //                                      }
184 //                                      requestor.acceptResult(result);
185 //                              }
186 //                      };
187 //              }
188                 this.problemReporter =
189                         new ProblemReporter(policy, problemFactory);//, this.options, problemFactory);
190                 this.lookupEnvironment =
191                         new LookupEnvironment(this, problemReporter, environment);//options, problemReporter, environment);
192                 this.parser =
193                         new UnitParser(
194                                 problemReporter); 
195 //                              parseLiteralExpressionsAsConstants,
196                                 //                              this.options.sourceLevel >= CompilerOptions.JDK1_4);
197         }
198         
199         /**
200          * Add an additional binary type
201          */
202         public void accept(IBinaryType binaryType, PackageBinding packageBinding) {
203                 lookupEnvironment.createBinaryTypeFrom(binaryType, packageBinding);
204         }
205
206         /**
207          * Add an additional compilation unit into the loop
208          *  ->  build compilation unit declarations, their bindings and record their results.
209          */
210         public void accept(ICompilationUnit sourceUnit) {
211                 // Switch the current policy and compilation result for this unit to the requested one.
212                 CompilationResult unitResult =
213                         new CompilationResult(sourceUnit, totalUnits, totalUnits, 10); //this.options.maxProblemsPerUnit);
214                 try {
215                         // diet parsing for large collection of unit
216                         CompilationUnitDeclaration parsedUnit;
217                         if (totalUnits < parseThreshold) {
218                                 parsedUnit = parser.parse(sourceUnit, unitResult,false);
219                         } else {
220                                 parsedUnit = parser.dietParse(sourceUnit, unitResult);
221                         }
222
223 //                      if (options.verbose) {
224 //                              String count = String.valueOf(totalUnits + 1);
225 //                              System.out.println(
226 //                                      Util.bind(
227 //                                              "compilation.request" , //$NON-NLS-1$
228 //                                              new String[] {
229 //                                                      count,
230 //                                                      count,
231 //                                                      new String(sourceUnit.getFileName())}));
232 //                      }
233
234                         // initial type binding creation
235                         lookupEnvironment.buildTypeBindings(parsedUnit);
236                         this.addCompilationUnit(sourceUnit, parsedUnit);
237
238                         // binding resolution
239                         lookupEnvironment.completeTypeBindings(parsedUnit);
240                 } catch (AbortCompilationUnit e) {
241                         // at this point, currentCompilationUnitResult may not be sourceUnit, but some other
242                         // one requested further along to resolve sourceUnit.
243                         if (unitResult.compilationUnit == sourceUnit) { // only report once
244                                 requestor.acceptResult(unitResult.tagAsAccepted());
245                         } else {
246                                 throw e; // want to abort enclosing request to compile
247                         }
248                 }
249         }
250
251         /**
252          * Add additional source types
253          */
254         public void accept(ISourceType[] sourceTypes, PackageBinding packageBinding) {
255                 problemReporter.abortDueToInternalError(
256                         Util.bind(
257                                 "abort.againstSourceModel " , //$NON-NLS-1$
258                                 String.valueOf(sourceTypes[0].getName()),
259                                 String.valueOf(sourceTypes[0].getFileName())));
260         }
261
262         protected void addCompilationUnit(
263                 ICompilationUnit sourceUnit,
264                 CompilationUnitDeclaration parsedUnit) {
265
266                 // append the unit to the list of ones to process later on
267                 int size = unitsToProcess.length;
268                 if (totalUnits == size)
269                         // when growing reposition units starting at position 0
270                         System.arraycopy(
271                                 unitsToProcess,
272                                 0,
273                                 (unitsToProcess = new CompilationUnitDeclaration[size * 2]),
274                                 0,
275                                 totalUnits);
276                 unitsToProcess[totalUnits++] = parsedUnit;
277         }
278
279         /**
280          * Add the initial set of compilation units into the loop
281          *  ->  build compilation unit declarations, their bindings and record their results.
282          */
283         protected void beginToCompile(ICompilationUnit[] sourceUnits) {
284                 int maxUnits = sourceUnits.length;
285                 totalUnits = 0;
286                 unitsToProcess = new CompilationUnitDeclaration[maxUnits];
287
288                 // Switch the current policy and compilation result for this unit to the requested one.
289                 for (int i = 0; i < maxUnits; i++) {
290                         CompilationUnitDeclaration parsedUnit;
291                         CompilationResult unitResult =
292                                 new CompilationResult(sourceUnits[i], i, maxUnits, 10);//, this.options.maxProblemsPerUnit);
293                         try {
294                                 // diet parsing for large collection of units
295                                 if (totalUnits < parseThreshold) {
296                                         parsedUnit = parser.parse(sourceUnits[i], unitResult, false);
297                                 } else {
298                                         parsedUnit = parser.dietParse(sourceUnits[i], unitResult);
299                                 }
300 //                              if (options.verbose) {
301 //                                      System.out.println(
302 //                                              Util.bind(
303 //                                                      "compilation.request" , //$NON-NLS-1$
304 //                                                      new String[] {
305 //                                                              String.valueOf(i + 1),
306 //                                                              String.valueOf(maxUnits),
307 //                                                              new String(sourceUnits[i].getFileName())}));
308 //                              }
309                                 // initial type binding creation
310                                 lookupEnvironment.buildTypeBindings(parsedUnit);
311                                 this.addCompilationUnit(sourceUnits[i], parsedUnit);
312                                 //} catch (AbortCompilationUnit e) {
313                                 //      requestor.acceptResult(unitResult.tagAsAccepted());
314                         } finally {
315                                 sourceUnits[i] = null; // no longer hold onto the unit
316                         }
317                 }
318                 // binding resolution
319                 lookupEnvironment.completeTypeBindings();
320         }
321
322         /**
323          * General API
324          * -> compile each of supplied files
325          * -> recompile any required types for which we have an incomplete principle structure
326          */
327         public void compile(ICompilationUnit[] sourceUnits) {
328                 CompilationUnitDeclaration unit = null;
329                 int i = 0;
330                 try {
331                         // build and record parsed units
332
333                         beginToCompile(sourceUnits);
334
335                         // process all units (some more could be injected in the loop by the lookup environment)
336                         for (; i < totalUnits; i++) {
337                                 unit = unitsToProcess[i];
338                                 try {
339 //                                      if (options.verbose)
340 //                                              System.out.println(
341 //                                                      Util.bind(
342 //                                                              "compilation.process" , //$NON-NLS-1$
343 //                                                              new String[] {
344 //                                                                      String.valueOf(i + 1),
345 //                                                                      String.valueOf(totalUnits),
346 //                                                                      new String(unitsToProcess[i].getFileName())}));
347                                         process(unit, i);
348                                 } finally {
349                                         // cleanup compilation unit result
350                                         unit.cleanUp();
351 //                                      if (options.verbose)
352 //                                              System.out.println(Util.bind("compilation.done", //$NON-NLS-1$
353 //                                      new String[] {
354 //                                              String.valueOf(i + 1),
355 //                                              String.valueOf(totalUnits),
356 //                                              new String(unitsToProcess[i].getFileName())}));
357                                 }
358                                 unitsToProcess[i] = null; // release reference to processed unit declaration
359                                 requestor.acceptResult(unit.compilationResult.tagAsAccepted());
360                         }
361                 } catch (AbortCompilation e) {
362                         this.handleInternalException(e, unit);
363                 } catch (Error e) {
364                         this.handleInternalException(e, unit, null);
365                         throw e; // rethrow
366                 } catch (RuntimeException e) {
367                         this.handleInternalException(e, unit, null);
368                         throw e; // rethrow
369                 } finally {
370                         this.reset();
371                 }
372 //              if (options.verbose) {
373 //                      if (totalUnits > 1) {
374 //                              System.out.println(
375 //                                      Util.bind("compilation.units" , String.valueOf(totalUnits))); //$NON-NLS-1$
376 //                      } else {
377 //                              System.out.println(
378 //                                      Util.bind("compilation.unit" , String.valueOf(totalUnits))); //$NON-NLS-1$
379 //                      }
380 //              }
381         }
382
383         protected void getMethodBodies(CompilationUnitDeclaration unit, int place) {
384                 //fill the methods bodies in order for the code to be generated
385
386                 if (unit.ignoreMethodBodies) {
387                         unit.ignoreFurtherInvestigation = true;
388                         return;
389                         // if initial diet parse did not work, no need to dig into method bodies.
390                 }
391
392                 if (place < parseThreshold)
393                         return; //work already done ...
394
395                 //real parse of the method....
396                 parser.scanner.setSource(
397                         unit.compilationResult.compilationUnit.getContents());
398                 if (unit.types != null) {
399                         for (int i = unit.types.size(); --i >= 0;)
400                           if (unit.types.get(i) instanceof TypeDeclaration) {
401                                   ((TypeDeclaration)unit.types.get(i)).parseMethod(parser, unit);
402                           }
403                 }
404         }
405
406         /*
407          * Compiler crash recovery in case of unexpected runtime exceptions
408          */
409         protected void handleInternalException(
410                 Throwable internalException,
411                 CompilationUnitDeclaration unit,
412                 CompilationResult result) {
413
414                 /* dump a stack trace to the console */
415                 internalException.printStackTrace();
416
417                 /* find a compilation result */
418                 if ((unit != null)) // basing result upon the current unit if available
419                         result = unit.compilationResult; // current unit being processed ?
420                 if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
421                         result = unitsToProcess[totalUnits - 1].compilationResult;
422                 // last unit in beginToCompile ?
423
424                 if (result != null) {
425                         /* create and record a compilation problem */
426                         StringWriter stringWriter = new StringWriter();
427                         PrintWriter writer = new PrintWriter(stringWriter);
428                         internalException.printStackTrace(writer);
429                         StringBuffer buffer = stringWriter.getBuffer();
430
431                         String[] pbArguments = new String[] {
432                                 Util.bind("compilation.internalError" ) //$NON-NLS-1$
433                                         + "\n"  //$NON-NLS-1$
434                                         + buffer.toString()};
435
436                         result
437                                 .record(
438                                         problemReporter
439                                         .createProblem(
440                                                 result.getFileName(),
441                                                 IProblem.Unclassified,
442                                                 pbArguments,
443                                                 pbArguments,
444                                                 Error, // severity
445                                                 0, // source start
446                                                 0, // source end
447                                                 0, // line number               
448                                                 unit,
449                                                 result),
450                                         unit);
451
452                         /* hand back the compilation result */
453                         if (!result.hasBeenAccepted) {
454                                 requestor.acceptResult(result.tagAsAccepted());
455                         }
456                 }
457         }
458
459         /*
460          * Compiler recovery in case of internal AbortCompilation event
461          */
462         protected void handleInternalException(
463                 AbortCompilation abortException,
464                 CompilationUnitDeclaration unit) {
465
466                 /* special treatment for SilentAbort: silently cancelling the compilation process */
467                 if (abortException.isSilent) {
468                         if (abortException.silentException == null) {
469                                 return;
470                         } else {
471                                 throw abortException.silentException;
472                         }
473                 }
474
475                 /* uncomment following line to see where the abort came from */
476                 // abortException.printStackTrace(); 
477
478                 // Exception may tell which compilation result it is related, and which problem caused it
479                 CompilationResult result = abortException.compilationResult;
480                 if ((result == null) && (unit != null))
481                         result = unit.compilationResult; // current unit being processed ?
482                 if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
483                         result = unitsToProcess[totalUnits - 1].compilationResult;
484                 // last unit in beginToCompile ?
485                 if (result != null && !result.hasBeenAccepted) {
486                         /* distant problem which could not be reported back there */
487                         if (abortException.problemId != 0) {
488                                 result
489                                         .record(
490                                                 problemReporter
491                                                 .createProblem(
492                                                         result.getFileName(),
493                                                         abortException.problemId,
494                                                         abortException.problemArguments,
495                                                         abortException.messageArguments,
496                                                         Error, // severity
497                                                         0, // source start
498                                                         0, // source end
499                                                         0, // line number               
500                                                         unit,
501                                                         result),
502                                                 unit);                          
503                         } else {
504                                 /* distant internal exception which could not be reported back there */
505                                 if (abortException.exception != null) {
506                                         this.handleInternalException(abortException.exception, null, result);
507                                         return;
508                                 }
509                         }
510                         /* hand back the compilation result */
511                         if (!result.hasBeenAccepted) {
512                                 requestor.acceptResult(result.tagAsAccepted());
513                         }
514                 } else {
515                         /*
516                         if (abortException.problemId != 0){ 
517                                 IProblem problem =
518                                         problemReporter.createProblem(
519                                                 "???".toCharArray(),
520                                                 abortException.problemId, 
521                                                 abortException.problemArguments, 
522                                                 Error, // severity
523                                                 0, // source start
524                                                 0, // source end
525                                                 0); // line number
526                                 System.out.println(problem.getMessage());
527                         }
528                         */
529                         abortException.printStackTrace();
530                 }
531         }
532
533         /**
534          * Process a compilation unit already parsed and build.
535          */
536         public void process(CompilationUnitDeclaration unit, int i) {
537
538                 getMethodBodies(unit, i);
539
540                 // fault in fields & methods
541                 if (unit.scope != null)
542                         unit.scope.faultInTypes();
543
544                 // verify inherited methods
545                 if (unit.scope != null)
546                         unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
547
548                 // type checking
549                 unit.resolve();
550
551                 // flow analysis
552                 unit.analyseCode();
553
554                 // code generation
555 //              unit.generateCode();
556
557                 // reference info
558 //              if (options.produceReferenceInfo && unit.scope != null)
559 //                      unit.scope.storeDependencyInfo();
560
561                 // refresh the total number of units known at this stage
562                 unit.compilationResult.totalUnitsKnown = totalUnits;
563         }
564         public void reset() {
565                 lookupEnvironment.reset();
566                 parser.scanner.source = null;
567                 unitsToProcess = null;
568 //              if (DebugRequestor != null) DebugRequestor.reset();
569         }
570
571         /**
572          * Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
573          */
574         public CompilationUnitDeclaration resolve(
575                         ICompilationUnit sourceUnit, 
576                         boolean verifyMethods,
577                         boolean analyzeCode) {
578 //                      boolean generateCode) {
579                                 
580                 CompilationUnitDeclaration unit = null;
581                 try {
582                         // build and record parsed units
583                         parseThreshold = 0; // will request a full parse
584                         beginToCompile(new ICompilationUnit[] { sourceUnit });
585                         // process all units (some more could be injected in the loop by the lookup environment)
586                         unit = unitsToProcess[0];
587                         getMethodBodies(unit, 0);
588                         if (unit.scope != null) {
589 //                              // fault in fields & methods
590 //                              unit.scope.faultInTypes();
591                                 
592 //                              if (unit.scope != null && verifyMethods) {
593 //                                      // http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
594 //                                      // verify inherited methods
595 //                                      unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
596 //                              }
597 //                              // type checking
598 //                              unit.resolve();         
599
600                                 // flow analysis
601 //                              if (analyzeCode) unit.analyseCode();
602                 
603                                 // code generation
604 //                              if (generateCode) unit.generateCode();
605                         }
606                         unitsToProcess[0] = null; // release reference to processed unit declaration
607                         requestor.acceptResult(unit.compilationResult.tagAsAccepted());
608                         return unit;
609                 } catch (AbortCompilation e) {
610                         this.handleInternalException(e, unit);
611                         return unit == null ? unitsToProcess[0] : unit;
612                 } catch (Error e) {
613                         this.handleInternalException(e, unit, null);
614                         throw e; // rethrow
615                 } catch (RuntimeException e) {
616                         this.handleInternalException(e, unit, null);
617                         throw e; // rethrow
618                 } finally {
619                         // No reset is performed there anymore since,
620                         // within the CodeAssist (or related tools),
621                         // the compiler may be called *after* a call
622                         // to this resolve(...) method. And such a call
623                         // needs to have a compiler with a non-empty
624                         // environment.
625                         // this.reset();
626                 }
627         }
628 }