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