X-Git-Url: http://git.phpeclipse.com

diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java
index 6583d9e..76286a7 100644
--- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java
+++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java
@@ -15,10 +15,13 @@ import java.io.StringWriter;
 import java.util.Map;
 
 import net.sourceforge.phpdt.core.compiler.IProblem;
+import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
+import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
 import net.sourceforge.phpdt.internal.compiler.env.IBinaryType;
 import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
 import net.sourceforge.phpdt.internal.compiler.env.INameEnvironment;
 import net.sourceforge.phpdt.internal.compiler.env.ISourceType;
+import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
 import net.sourceforge.phpdt.internal.compiler.impl.ITypeRequestor;
 import net.sourceforge.phpdt.internal.compiler.lookup.LookupEnvironment;
 import net.sourceforge.phpdt.internal.compiler.lookup.PackageBinding;
@@ -28,174 +31,182 @@ import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilationUnit;
 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
 import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities;
 import net.sourceforge.phpdt.internal.compiler.util.Util;
-import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
-import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
 
 public class Compiler implements ITypeRequestor, ProblemSeverities {
 	public UnitParser parser;
+
 	public ICompilerRequestor requestor;
-//	public CompilerOptions options;
+
+	public CompilerOptions options;
+
 	public ProblemReporter problemReporter;
 
 	// management of unit to be processed
-	//public CompilationUnitResult currentCompilationUnitResult;
+	// public CompilationUnitResult currentCompilationUnitResult;
 	public CompilationUnitDeclaration[] unitsToProcess;
-	public int totalUnits; // (totalUnits-1) gives the last unit in unitToProcess
+
+	public int totalUnits; // (totalUnits-1) gives the last unit in
+							// unitToProcess
 
 	// name lookup
 	public LookupEnvironment lookupEnvironment;
 
 	// ONCE STABILIZED, THESE SHOULD RETURN TO A FINAL FIELD
 	public static boolean DEBUG = false;
+
 	public int parseThreshold = -1;
-	// number of initial units parsed at once (-1: none)
 
+	// number of initial units parsed at once (-1: none)
 	/*
 	 * Static requestor reserved to listening compilation results in debug mode,
-	 * so as for example to monitor compiler activity independantly from a particular
-	 * builder implementation. It is reset at the end of compilation, and should not 
-	 * persist any information after having been reset.
+	 * so as for example to monitor compiler activity independantly from a
+	 * particular builder implementation. It is reset at the end of compilation,
+	 * and should not persist any information after having been reset.
 	 */
-//	public static IDebugRequestor DebugRequestor = null;
-
+	// public static IDebugRequestor DebugRequestor = null;
 	/**
-	 * Answer a new compiler using the given name environment and compiler options.
-	 * The environment and options will be in effect for the lifetime of the compiler.
-	 * When the compiler is run, compilation results are sent to the given requestor.
-	 *
-	 *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
-	 *      Environment used by the compiler in order to resolve type and package
-	 *      names. The name environment implements the actual connection of the compiler
-	 *      to the outside world (e.g. in batch mode the name environment is performing
-	 *      pure file accesses, reuse previous build state or connection to repositories).
-	 *      Note: the name environment is responsible for implementing the actual classpath
-	 *            rules.
-	 *
-	 *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
-	 *      Configurable part for problem handling, allowing the compiler client to
-	 *      specify the rules for handling problems (stop on first error or accumulate
-	 *      them all) and at the same time perform some actions such as opening a dialog
-	 *      in UI when compiling interactively.
-	 *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
-	 *      
-	 *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
-	 *      Component which will receive and persist all compilation results and is intended
-	 *      to consume them as they are produced. Typically, in a batch compiler, it is 
-	 *      responsible for writing out the actual .class files to the file system.
-	 *      @see org.eclipse.jdt.internal.compiler.CompilationResult
-	 *
-	 *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
-	 *      Factory used inside the compiler to create problem descriptors. It allows the
-	 *      compiler client to supply its own representation of compilation problems in
-	 *      order to avoid object conversions. Note that the factory is not supposed
-	 *      to accumulate the created problems, the compiler will gather them all and hand
-	 *      them back as part of the compilation unit result.
+	 * Answer a new compiler using the given name environment and compiler
+	 * options. The environment and options will be in effect for the lifetime
+	 * of the compiler. When the compiler is run, compilation results are sent
+	 * to the given requestor.
+	 * 
+	 * @param environment
+	 *            org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
+	 *            Environment used by the compiler in order to resolve type and
+	 *            package names. The name environment implements the actual
+	 *            connection of the compiler to the outside world (e.g. in batch
+	 *            mode the name environment is performing pure file accesses,
+	 *            reuse previous build state or connection to repositories).
+	 *            Note: the name environment is responsible for implementing the
+	 *            actual classpath rules.
+	 * 
+	 * @param policy
+	 *            org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
+	 *            Configurable part for problem handling, allowing the compiler
+	 *            client to specify the rules for handling problems (stop on
+	 *            first error or accumulate them all) and at the same time
+	 *            perform some actions such as opening a dialog in UI when
+	 *            compiling interactively.
+	 * @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
+	 * 
+	 * @param requestor
+	 *            org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
+	 *            Component which will receive and persist all compilation
+	 *            results and is intended to consume them as they are produced.
+	 *            Typically, in a batch compiler, it is responsible for writing
+	 *            out the actual .class files to the file system.
+	 * @see org.eclipse.jdt.internal.compiler.CompilationResult
+	 * 
+	 * @param problemFactory
+	 *            org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
+	 *            Factory used inside the compiler to create problem
+	 *            descriptors. It allows the compiler client to supply its own
+	 *            representation of compilation problems in order to avoid
+	 *            object conversions. Note that the factory is not supposed to
+	 *            accumulate the created problems, the compiler will gather them
+	 *            all and hand them back as part of the compilation unit result.
 	 */
-	public Compiler(
-		INameEnvironment environment,
-		IErrorHandlingPolicy policy,
-//		Map settings,
-		final ICompilerRequestor requestor,
-		IProblemFactory problemFactory) {
-
+	public Compiler(INameEnvironment environment, IErrorHandlingPolicy policy,
+			Map settings, final ICompilerRequestor requestor,
+			IProblemFactory problemFactory) {
 		// create a problem handler given a handling policy
-//		this.options = new CompilerOptions(settings);
-		
+		this.options = new CompilerOptions(settings);
 		// wrap requestor in DebugRequestor if one is specified
-//		if(DebugRequestor == null) {
-			this.requestor = requestor;
-//		} else {
-//			this.requestor = new ICompilerRequestor(){
-//				public void acceptResult(CompilationResult result){
-//					if (DebugRequestor.isActive()){
-//						DebugRequestor.acceptDebugResult(result);
-//					}
-//					requestor.acceptResult(result);
-//				}
-//			};
-//		}
-		this.problemReporter =
-			new ProblemReporter(policy, problemFactory);//this.options, problemFactory);
-		this.lookupEnvironment =
-			new LookupEnvironment(this, problemReporter, environment); //options, problemReporter, environment);
-		this.parser =
-			new UnitParser(
-				problemReporter); 
-//				this.options.parseLiteralExpressionsAsConstants, 
-//				options.sourceLevel >= CompilerOptions.JDK1_4);
+		// if(DebugRequestor == null) {
+		this.requestor = requestor;
+		// } else {
+		// this.requestor = new ICompilerRequestor(){
+		// public void acceptResult(CompilationResult result){
+		// if (DebugRequestor.isActive()){
+		// DebugRequestor.acceptDebugResult(result);
+		// }
+		// requestor.acceptResult(result);
+		// }
+		// };
+		// }
+		this.problemReporter = new ProblemReporter(policy, this.options,
+				problemFactory);
+		this.lookupEnvironment = new LookupEnvironment(this, problemReporter,
+				environment); // options, problemReporter, environment);
+		this.parser = new UnitParser(problemReporter);
+		// this.options.parseLiteralExpressionsAsConstants,
+		// options.sourceLevel >= CompilerOptions.JDK1_4);
 	}
-	
+
 	/**
-	 * Answer a new compiler using the given name environment and compiler options.
-	 * The environment and options will be in effect for the lifetime of the compiler.
-	 * When the compiler is run, compilation results are sent to the given requestor.
-	 *
-	 *  @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
-	 *      Environment used by the compiler in order to resolve type and package
-	 *      names. The name environment implements the actual connection of the compiler
-	 *      to the outside world (e.g. in batch mode the name environment is performing
-	 *      pure file accesses, reuse previous build state or connection to repositories).
-	 *      Note: the name environment is responsible for implementing the actual classpath
-	 *            rules.
-	 *
-	 *  @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
-	 *      Configurable part for problem handling, allowing the compiler client to
-	 *      specify the rules for handling problems (stop on first error or accumulate
-	 *      them all) and at the same time perform some actions such as opening a dialog
-	 *      in UI when compiling interactively.
-	 *      @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
-	 *      
-	 *  @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
-	 *      Component which will receive and persist all compilation results and is intended
-	 *      to consume them as they are produced. Typically, in a batch compiler, it is 
-	 *      responsible for writing out the actual .class files to the file system.
-	 *      @see org.eclipse.jdt.internal.compiler.CompilationResult
-	 *
-	 *  @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
-	 *      Factory used inside the compiler to create problem descriptors. It allows the
-	 *      compiler client to supply its own representation of compilation problems in
-	 *      order to avoid object conversions. Note that the factory is not supposed
-	 *      to accumulate the created problems, the compiler will gather them all and hand
-	 *      them back as part of the compilation unit result.
-	 *	@param parseLiteralExpressionsAsConstants <code>boolean</code>
-	 *		This parameter is used to optimize the literals or leave them as they are in the source.
-	 * 		If you put true, "Hello" + " world" will be converted to "Hello world".
+	 * Answer a new compiler using the given name environment and compiler
+	 * options. The environment and options will be in effect for the lifetime
+	 * of the compiler. When the compiler is run, compilation results are sent
+	 * to the given requestor.
+	 * 
+	 * @param environment
+	 *            org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
+	 *            Environment used by the compiler in order to resolve type and
+	 *            package names. The name environment implements the actual
+	 *            connection of the compiler to the outside world (e.g. in batch
+	 *            mode the name environment is performing pure file accesses,
+	 *            reuse previous build state or connection to repositories).
+	 *            Note: the name environment is responsible for implementing the
+	 *            actual classpath rules.
+	 * 
+	 * @param policy
+	 *            org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
+	 *            Configurable part for problem handling, allowing the compiler
+	 *            client to specify the rules for handling problems (stop on
+	 *            first error or accumulate them all) and at the same time
+	 *            perform some actions such as opening a dialog in UI when
+	 *            compiling interactively.
+	 * @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
+	 * 
+	 * @param requestor
+	 *            org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
+	 *            Component which will receive and persist all compilation
+	 *            results and is intended to consume them as they are produced.
+	 *            Typically, in a batch compiler, it is responsible for writing
+	 *            out the actual .class files to the file system.
+	 * @see org.eclipse.jdt.internal.compiler.CompilationResult
+	 * 
+	 * @param problemFactory
+	 *            org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
+	 *            Factory used inside the compiler to create problem
+	 *            descriptors. It allows the compiler client to supply its own
+	 *            representation of compilation problems in order to avoid
+	 *            object conversions. Note that the factory is not supposed to
+	 *            accumulate the created problems, the compiler will gather them
+	 *            all and hand them back as part of the compilation unit result.
+	 * @param parseLiteralExpressionsAsConstants
+	 *            <code>boolean</code> This parameter is used to optimize the
+	 *            literals or leave them as they are in the source. If you put
+	 *            true, "Hello" . " world" will be converted to "Hello world".
 	 */
-	public Compiler(
-		INameEnvironment environment,
-		IErrorHandlingPolicy policy,
-//		Map settings,
-		final ICompilerRequestor requestor,
-		IProblemFactory problemFactory,
-		boolean parseLiteralExpressionsAsConstants) {
-
+	public Compiler(INameEnvironment environment, IErrorHandlingPolicy policy,
+			Map settings, final ICompilerRequestor requestor,
+			IProblemFactory problemFactory,
+			boolean parseLiteralExpressionsAsConstants) {
 		// create a problem handler given a handling policy
-//		this.options = new CompilerOptions(settings);
-		
+		this.options = new CompilerOptions(settings);
 		// wrap requestor in DebugRequestor if one is specified
-//		if(DebugRequestor == null) {
-			this.requestor = requestor;
-//		} else {
-//			this.requestor = new ICompilerRequestor(){
-//				public void acceptResult(CompilationResult result){
-//					if (DebugRequestor.isActive()){
-//						DebugRequestor.acceptDebugResult(result);
-//					}
-//					requestor.acceptResult(result);
-//				}
-//			};
-//		}
-		this.problemReporter =
-			new ProblemReporter(policy, problemFactory);//, this.options, problemFactory);
-		this.lookupEnvironment =
-			new LookupEnvironment(this, problemReporter, environment);//options, problemReporter, environment);
-		this.parser =
-			new UnitParser(
-				problemReporter); 
-//				parseLiteralExpressionsAsConstants,
-				//				this.options.sourceLevel >= CompilerOptions.JDK1_4);
+		// if(DebugRequestor == null) {
+		this.requestor = requestor;
+		// } else {
+		// this.requestor = new ICompilerRequestor(){
+		// public void acceptResult(CompilationResult result){
+		// if (DebugRequestor.isActive()){
+		// DebugRequestor.acceptDebugResult(result);
+		// }
+		// requestor.acceptResult(result);
+		// }
+		// };
+		// }
+		this.problemReporter = new ProblemReporter(policy, this.options,
+				problemFactory);
+		this.lookupEnvironment = new LookupEnvironment(this, problemReporter,
+				environment);// options, problemReporter, environment);
+		this.parser = new UnitParser(problemReporter);
+		// parseLiteralExpressionsAsConstants,
+		// this.options.sourceLevel >= CompilerOptions.JDK1_4);
 	}
-	
+
 	/**
 	 * Add an additional binary type
 	 */
@@ -204,41 +215,37 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 	}
 
 	/**
-	 * Add an additional compilation unit into the loop
-	 *  ->  build compilation unit declarations, their bindings and record their results.
+	 * Add an additional compilation unit into the loop -> build compilation
+	 * unit declarations, their bindings and record their results.
 	 */
 	public void accept(ICompilationUnit sourceUnit) {
-		// Switch the current policy and compilation result for this unit to the requested one.
-		CompilationResult unitResult =
-			new CompilationResult(sourceUnit, totalUnits, totalUnits, 10); //this.options.maxProblemsPerUnit);
+		// Switch the current policy and compilation result for this unit to the
+		// requested one.
+		CompilationResult unitResult = new CompilationResult(sourceUnit,
+				totalUnits, totalUnits, this.options.maxProblemsPerUnit);
 		try {
 			// diet parsing for large collection of unit
 			CompilationUnitDeclaration parsedUnit;
 			if (totalUnits < parseThreshold) {
-				parsedUnit = parser.parse(sourceUnit, unitResult);
+				parsedUnit = parser.parse(sourceUnit, unitResult, false);
 			} else {
 				parsedUnit = parser.dietParse(sourceUnit, unitResult);
 			}
-
-//			if (options.verbose) {
-//				String count = String.valueOf(totalUnits + 1);
-//				System.out.println(
-//					Util.bind(
-//						"compilation.request" , //$NON-NLS-1$
-//						new String[] {
-//							count,
-//							count,
-//							new String(sourceUnit.getFileName())}));
-//			}
-
+			if (options.verbose) {
+				String count = String.valueOf(totalUnits + 1);
+				System.out.println(Util.bind("compilation.request", //$NON-NLS-1$
+						new String[] { count, count,
+								new String(sourceUnit.getFileName()) }));
+			}
 			// initial type binding creation
 			lookupEnvironment.buildTypeBindings(parsedUnit);
 			this.addCompilationUnit(sourceUnit, parsedUnit);
-
 			// binding resolution
 			lookupEnvironment.completeTypeBindings(parsedUnit);
 		} catch (AbortCompilationUnit e) {
-			// at this point, currentCompilationUnitResult may not be sourceUnit, but some other
+			// at this point, currentCompilationUnitResult may not be
+			// sourceUnit, but
+			// some other
 			// one requested further along to resolve sourceUnit.
 			if (unitResult.compilationUnit == sourceUnit) { // only report once
 				requestor.acceptResult(unitResult.tagAsAccepted());
@@ -252,65 +259,64 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 	 * Add additional source types
 	 */
 	public void accept(ISourceType[] sourceTypes, PackageBinding packageBinding) {
-		problemReporter.abortDueToInternalError(
-			Util.bind(
-				"abort.againstSourceModel " , //$NON-NLS-1$
-				String.valueOf(sourceTypes[0].getName()),
-				String.valueOf(sourceTypes[0].getFileName())));
+		problemReporter.abortDueToInternalError(Util.bind(
+				"abort.againstSourceModel ", //$NON-NLS-1$
+				String.valueOf(sourceTypes[0].getName()), String
+						.valueOf(sourceTypes[0].getFileName())));
 	}
 
-	protected void addCompilationUnit(
-		ICompilationUnit sourceUnit,
-		CompilationUnitDeclaration parsedUnit) {
-
+	protected void addCompilationUnit(ICompilationUnit sourceUnit,
+			CompilationUnitDeclaration parsedUnit) {
 		// append the unit to the list of ones to process later on
 		int size = unitsToProcess.length;
 		if (totalUnits == size)
 			// when growing reposition units starting at position 0
-			System.arraycopy(
-				unitsToProcess,
-				0,
-				(unitsToProcess = new CompilationUnitDeclaration[size * 2]),
-				0,
-				totalUnits);
+			System
+					.arraycopy(
+							unitsToProcess,
+							0,
+							(unitsToProcess = new CompilationUnitDeclaration[size * 2]),
+							0, totalUnits);
 		unitsToProcess[totalUnits++] = parsedUnit;
 	}
 
 	/**
-	 * Add the initial set of compilation units into the loop
-	 *  ->  build compilation unit declarations, their bindings and record their results.
+	 * Add the initial set of compilation units into the loop -> build
+	 * compilation unit declarations, their bindings and record their results.
 	 */
 	protected void beginToCompile(ICompilationUnit[] sourceUnits) {
 		int maxUnits = sourceUnits.length;
 		totalUnits = 0;
 		unitsToProcess = new CompilationUnitDeclaration[maxUnits];
-
-		// Switch the current policy and compilation result for this unit to the requested one.
+		// Switch the current policy and compilation result for this unit to the
+		// requested one.
 		for (int i = 0; i < maxUnits; i++) {
 			CompilationUnitDeclaration parsedUnit;
-			CompilationResult unitResult =
-				new CompilationResult(sourceUnits[i], i, maxUnits, 10);//, this.options.maxProblemsPerUnit);
+			CompilationResult unitResult = new CompilationResult(
+					sourceUnits[i], i, maxUnits,
+					this.options.maxProblemsPerUnit);
 			try {
 				// diet parsing for large collection of units
 				if (totalUnits < parseThreshold) {
-					parsedUnit = parser.parse(sourceUnits[i], unitResult);
+					parsedUnit = parser
+							.parse(sourceUnits[i], unitResult, false);
 				} else {
 					parsedUnit = parser.dietParse(sourceUnits[i], unitResult);
 				}
-//				if (options.verbose) {
-//					System.out.println(
-//						Util.bind(
-//							"compilation.request" , //$NON-NLS-1$
-//							new String[] {
-//								String.valueOf(i + 1),
-//								String.valueOf(maxUnits),
-//								new String(sourceUnits[i].getFileName())}));
-//				}
+				if (options.verbose) {
+					System.out
+							.println(Util.bind("compilation.request", //$NON-NLS-1$
+									new String[] {
+											String.valueOf(i + 1),
+											String.valueOf(maxUnits),
+											new String(sourceUnits[i]
+													.getFileName()) }));
+				}
 				// initial type binding creation
-				lookupEnvironment.buildTypeBindings(parsedUnit);
+				// lookupEnvironment.buildTypeBindings(parsedUnit);
 				this.addCompilationUnit(sourceUnits[i], parsedUnit);
-				//} catch (AbortCompilationUnit e) {
-				//	requestor.acceptResult(unitResult.tagAsAccepted());
+				// } catch (AbortCompilationUnit e) {
+				// requestor.acceptResult(unitResult.tagAsAccepted());
 			} finally {
 				sourceUnits[i] = null; // no longer hold onto the unit
 			}
@@ -320,42 +326,42 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 	}
 
 	/**
-	 * General API
-	 * -> compile each of supplied files
-	 * -> recompile any required types for which we have an incomplete principle structure
+	 * General API -> compile each of supplied files -> recompile any required
+	 * types for which we have an incomplete principle structure
 	 */
 	public void compile(ICompilationUnit[] sourceUnits) {
 		CompilationUnitDeclaration unit = null;
 		int i = 0;
 		try {
 			// build and record parsed units
-
 			beginToCompile(sourceUnits);
-
-			// process all units (some more could be injected in the loop by the lookup environment)
+			// process all units (some more could be injected in the loop by the
+			// lookup environment)
 			for (; i < totalUnits; i++) {
 				unit = unitsToProcess[i];
 				try {
-//					if (options.verbose)
-//						System.out.println(
-//							Util.bind(
-//								"compilation.process" , //$NON-NLS-1$
-//								new String[] {
-//									String.valueOf(i + 1),
-//									String.valueOf(totalUnits),
-//									new String(unitsToProcess[i].getFileName())}));
+					if (options.verbose)
+						System.out.println(Util.bind("compilation.process", //$NON-NLS-1$
+								new String[] {
+										String.valueOf(i + 1),
+										String.valueOf(totalUnits),
+										new String(unitsToProcess[i]
+												.getFileName()) }));
 					process(unit, i);
 				} finally {
 					// cleanup compilation unit result
 					unit.cleanUp();
-//					if (options.verbose)
-//						System.out.println(Util.bind("compilation.done", //$NON-NLS-1$
-//					new String[] {
-//						String.valueOf(i + 1),
-//						String.valueOf(totalUnits),
-//						new String(unitsToProcess[i].getFileName())}));
+					if (options.verbose)
+						System.out.println(Util.bind("compilation.done", //$NON-NLS-1$
+								new String[] {
+										String.valueOf(i + 1),
+										String.valueOf(totalUnits),
+										new String(unitsToProcess[i]
+												.getFileName()) }));
 				}
-				unitsToProcess[i] = null; // release reference to processed unit declaration
+				unitsToProcess[i] = null; // release reference to processed
+											// unit
+				// declaration
 				requestor.acceptResult(unit.compilationResult.tagAsAccepted());
 			}
 		} catch (AbortCompilation e) {
@@ -369,86 +375,74 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 		} finally {
 			this.reset();
 		}
-//		if (options.verbose) {
-//			if (totalUnits > 1) {
-//				System.out.println(
-//					Util.bind("compilation.units" , String.valueOf(totalUnits))); //$NON-NLS-1$
-//			} else {
-//				System.out.println(
-//					Util.bind("compilation.unit" , String.valueOf(totalUnits))); //$NON-NLS-1$
-//			}
-//		}
+		// if (options.verbose) {
+		// if (totalUnits > 1) {
+		// System.out.println(
+		// ProjectPrefUtil.bind("compilation.units" ,
+		// String.valueOf(totalUnits)));
+		// //$NON-NLS-1$
+		// } else {
+		// System.out.println(
+		// ProjectPrefUtil.bind("compilation.unit" ,
+		// String.valueOf(totalUnits)));
+		// //$NON-NLS-1$
+		// }
+		// }
 	}
 
 	protected void getMethodBodies(CompilationUnitDeclaration unit, int place) {
-		//fill the methods bodies in order for the code to be generated
-
+		// fill the methods bodies in order for the code to be generated
 		if (unit.ignoreMethodBodies) {
 			unit.ignoreFurtherInvestigation = true;
 			return;
-			// if initial diet parse did not work, no need to dig into method bodies.
+			// if initial diet parse did not work, no need to dig into method
+			// bodies.
 		}
-
 		if (place < parseThreshold)
-			return; //work already done ...
-
-		//real parse of the method....
-		parser.scanner.setSource(
-			unit.compilationResult.compilationUnit.getContents());
+			return; // work already done ...
+		// real parse of the method....
+		parser.scanner.setSource(unit.compilationResult.compilationUnit
+				.getContents());
 		if (unit.types != null) {
 			for (int i = unit.types.size(); --i >= 0;)
-			  if (unit.types.get(i) instanceof TypeDeclaration) {
-				  ((TypeDeclaration)unit.types.get(i)).parseMethod(parser, unit);
-			  }
+				if (unit.types.get(i) instanceof TypeDeclaration) {
+					((TypeDeclaration) unit.types.get(i)).parseMethod(parser,
+							unit);
+				}
 		}
 	}
 
 	/*
 	 * Compiler crash recovery in case of unexpected runtime exceptions
 	 */
-	protected void handleInternalException(
-		Throwable internalException,
-		CompilationUnitDeclaration unit,
-		CompilationResult result) {
-
+	protected void handleInternalException(Throwable internalException,
+			CompilationUnitDeclaration unit, CompilationResult result) {
 		/* dump a stack trace to the console */
 		internalException.printStackTrace();
-
 		/* find a compilation result */
 		if ((unit != null)) // basing result upon the current unit if available
-			result = unit.compilationResult; // current unit being processed ?
+			result = unit.compilationResult; // current unit being processed
+												// ?
 		if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
 			result = unitsToProcess[totalUnits - 1].compilationResult;
 		// last unit in beginToCompile ?
-
 		if (result != null) {
 			/* create and record a compilation problem */
 			StringWriter stringWriter = new StringWriter();
 			PrintWriter writer = new PrintWriter(stringWriter);
 			internalException.printStackTrace(writer);
 			StringBuffer buffer = stringWriter.getBuffer();
-
-			String[] pbArguments = new String[] {
-				Util.bind("compilation.internalError" ) //$NON-NLS-1$
-					+ "\n"  //$NON-NLS-1$
-					+ buffer.toString()};
-
-			result
-				.record(
-					problemReporter
-					.createProblem(
-						result.getFileName(),
-						IProblem.Unclassified,
-						pbArguments,
-						pbArguments,
-						Error, // severity
-						0, // source start
-						0, // source end
-						0, // line number		
-						unit,
-						result),
-					unit);
-
+			String[] pbArguments = new String[] { Util
+					.bind("compilation.internalError")
+					//$NON-NLS-1$
+					+ "\n" //$NON-NLS-1$
+					+ buffer.toString() };
+			result.record(problemReporter.createProblem(result.getFileName(),
+					IProblem.Unclassified, pbArguments, pbArguments, Error, // severity
+					0, // source start
+					0, // source end
+					0, // line number
+					unit, result), unit);
 			/* hand back the compilation result */
 			if (!result.hasBeenAccepted) {
 				requestor.acceptResult(result.tagAsAccepted());
@@ -459,11 +453,12 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 	/*
 	 * Compiler recovery in case of internal AbortCompilation event
 	 */
-	protected void handleInternalException(
-		AbortCompilation abortException,
-		CompilationUnitDeclaration unit) {
-
-		/* special treatment for SilentAbort: silently cancelling the compilation process */
+	protected void handleInternalException(AbortCompilation abortException,
+			CompilationUnitDeclaration unit) {
+		/*
+		 * special treatment for SilentAbort: silently cancelling the
+		 * compilation process
+		 */
 		if (abortException.isSilent) {
 			if (abortException.silentException == null) {
 				return;
@@ -471,39 +466,36 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 				throw abortException.silentException;
 			}
 		}
-
 		/* uncomment following line to see where the abort came from */
-		// abortException.printStackTrace(); 
-
-		// Exception may tell which compilation result it is related, and which problem caused it
+		// abortException.printStackTrace();
+		// Exception may tell which compilation result it is related, and which
+		// problem caused it
 		CompilationResult result = abortException.compilationResult;
 		if ((result == null) && (unit != null))
-			result = unit.compilationResult; // current unit being processed ?
+			result = unit.compilationResult; // current unit being processed
+												// ?
 		if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
 			result = unitsToProcess[totalUnits - 1].compilationResult;
 		// last unit in beginToCompile ?
 		if (result != null && !result.hasBeenAccepted) {
 			/* distant problem which could not be reported back there */
 			if (abortException.problemId != 0) {
-				result
-					.record(
-						problemReporter
-						.createProblem(
-							result.getFileName(),
-							abortException.problemId,
-							abortException.problemArguments,
-							abortException.messageArguments,
-							Error, // severity
-							0, // source start
-							0, // source end
-							0, // line number		
-							unit,
-							result),
-						unit);				
+				result.record(problemReporter.createProblem(result
+						.getFileName(), abortException.problemId,
+						abortException.problemArguments,
+						abortException.messageArguments, Error, // severity
+						0, // source start
+						0, // source end
+						0, // line number
+						unit, result), unit);
 			} else {
-				/* distant internal exception which could not be reported back there */
+				/*
+				 * distant internal exception which could not be reported back
+				 * there
+				 */
 				if (abortException.exception != null) {
-					this.handleInternalException(abortException.exception, null, result);
+					this.handleInternalException(abortException.exception,
+							null, result);
 					return;
 				}
 			}
@@ -513,19 +505,12 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 			}
 		} else {
 			/*
-			if (abortException.problemId != 0){ 
-				IProblem problem =
-					problemReporter.createProblem(
-						"???".toCharArray(),
-						abortException.problemId, 
-						abortException.problemArguments, 
-						Error, // severity
-						0, // source start
-						0, // source end
-						0); // line number
-				System.out.println(problem.getMessage());
-			}
-			*/
+			 * if (abortException.problemId != 0){ IProblem problem =
+			 * problemReporter.createProblem( "???".toCharArray(),
+			 * abortException.problemId, abortException.problemArguments, Error, //
+			 * severity 0, // source start 0, // source end 0); // line number
+			 * System.out.println(problem.getMessage()); }
+			 */
 			abortException.printStackTrace();
 		}
 	}
@@ -534,76 +519,136 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 	 * Process a compilation unit already parsed and build.
 	 */
 	public void process(CompilationUnitDeclaration unit, int i) {
-
 		getMethodBodies(unit, i);
-
 		// fault in fields & methods
 		if (unit.scope != null)
 			unit.scope.faultInTypes();
-
 		// verify inherited methods
-		if (unit.scope != null)
-			unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
-
+		// if (unit.scope != null)
+		// unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
 		// type checking
 		unit.resolve();
-
 		// flow analysis
 		unit.analyseCode();
-
 		// code generation
-//		unit.generateCode();
-
+		// unit.generateCode();
 		// reference info
-//		if (options.produceReferenceInfo && unit.scope != null)
-//			unit.scope.storeDependencyInfo();
-
+		// if (options.produceReferenceInfo && unit.scope != null)
+		// unit.scope.storeDependencyInfo();
 		// refresh the total number of units known at this stage
 		unit.compilationResult.totalUnitsKnown = totalUnits;
 	}
+
 	public void reset() {
 		lookupEnvironment.reset();
 		parser.scanner.source = null;
 		unitsToProcess = null;
-//		if (DebugRequestor != null) DebugRequestor.reset();
+		// if (DebugRequestor != null) DebugRequestor.reset();
 	}
 
 	/**
-	 * Internal API used to resolve a given compilation unit. Can run a subset of the compilation process
+	 * Internal API used to resolve a given compilation unit. Can run a subset
+	 * of the compilation process
 	 */
-	public CompilationUnitDeclaration resolve(
-			ICompilationUnit sourceUnit, 
-			boolean verifyMethods,
+	public CompilationUnitDeclaration resolve(CompilationUnitDeclaration unit,
+			ICompilationUnit sourceUnit, boolean verifyMethods,
 			boolean analyzeCode) {
-//			boolean generateCode) {
-				
+
+		try {
+			if (unit == null) {
+				// build and record parsed units
+				parseThreshold = 0; // will request a full parse
+				beginToCompile(new ICompilationUnit[] { sourceUnit });
+				// process all units (some more could be injected in the loop by
+				// the lookup environment)
+				unit = unitsToProcess[0];
+			} else {
+				// initial type binding creation
+				lookupEnvironment.buildTypeBindings(unit);
+
+				// binding resolution
+				lookupEnvironment.completeTypeBindings();
+			}
+			// TODO : jsurfer check this
+			// this.parser.getMethodBodies(unit);
+			getMethodBodies(unit, 0);
+
+			if (unit.scope != null) {
+				// fault in fields & methods
+				unit.scope.faultInTypes();
+				if (unit.scope != null && verifyMethods) {
+					// http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
+					// verify inherited methods
+					unit.scope
+							.verifyMethods(lookupEnvironment.methodVerifier());
+				}
+				// type checking
+				unit.resolve();
+
+				// flow analysis
+				// if (analyzeCode) unit.analyseCode();
+
+				// code generation
+				// if (generateCode) unit.generateCode();
+			}
+			if (unitsToProcess != null)
+				unitsToProcess[0] = null; // release reference to processed
+											// unit declaration
+			requestor.acceptResult(unit.compilationResult.tagAsAccepted());
+			return unit;
+		} catch (AbortCompilation e) {
+			this.handleInternalException(e, unit);
+			return unit == null ? unitsToProcess[0] : unit;
+		} catch (Error e) {
+			this.handleInternalException(e, unit, null);
+			throw e; // rethrow
+		} catch (RuntimeException e) {
+			this.handleInternalException(e, unit, null);
+			throw e; // rethrow
+		} finally {
+			// No reset is performed there anymore since,
+			// within the CodeAssist (or related tools),
+			// the compiler may be called *after* a call
+			// to this resolve(...) method. And such a call
+			// needs to have a compiler with a non-empty
+			// environment.
+			// this.reset();
+		}
+	}
+
+	/**
+	 * Internal API used to resolve a given compilation unit. Can run a subset
+	 * of the compilation process
+	 */
+	public CompilationUnitDeclaration resolve(ICompilationUnit sourceUnit,
+			boolean verifyMethods, boolean analyzeCode) {
+		// boolean generateCode) {
 		CompilationUnitDeclaration unit = null;
 		try {
 			// build and record parsed units
 			parseThreshold = 0; // will request a full parse
 			beginToCompile(new ICompilationUnit[] { sourceUnit });
-			// process all units (some more could be injected in the loop by the lookup environment)
+			// process all units (some more could be injected in the loop by the
+			// lookup environment)
 			unit = unitsToProcess[0];
 			getMethodBodies(unit, 0);
 			if (unit.scope != null) {
-//				// fault in fields & methods
-//				unit.scope.faultInTypes();
-				
-//				if (unit.scope != null && verifyMethods) {
-//					// http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
-// 					// verify inherited methods
-//					unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
-//				}
-//				// type checking
-//				unit.resolve();		
-
+				// // fault in fields & methods
+				// unit.scope.faultInTypes();
+				// if (unit.scope != null && verifyMethods) {
+				// // http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
+				// // verify inherited methods
+				// unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
+				// }
+				// // type checking
+				// unit.resolve();
 				// flow analysis
-//				if (analyzeCode) unit.analyseCode();
-		
+				// if (analyzeCode) unit.analyseCode();
 				// code generation
-//				if (generateCode) unit.generateCode();
+				// if (generateCode) unit.generateCode();
 			}
-			unitsToProcess[0] = null; // release reference to processed unit declaration
+			unitsToProcess[0] = null; // release reference to processed unit
+			// declaration
 			requestor.acceptResult(unit.compilationResult.tagAsAccepted());
 			return unit;
 		} catch (AbortCompilation e) {
@@ -625,4 +670,5 @@ public class Compiler implements ITypeRequestor, ProblemSeverities {
 			// this.reset();
 		}
 	}
-}
+
+}
\ No newline at end of file