2.4/dev/core/src/com/google/gwt/dev/jdt/AbstractCompiler.java - gwt - Git at Google

 /*
  * Copyright 2008 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.dev.jdt;

 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.TreeLogger.HelpInfo;
 import com.google.gwt.dev.javac.CompilationState;
 import com.google.gwt.dev.javac.CompilationUnit;
 import com.google.gwt.dev.javac.GWTProblem;
 import com.google.gwt.dev.javac.JdtCompiler;
 import com.google.gwt.dev.javac.Shared;
 import com.google.gwt.dev.util.CharArrayComparator;
 import com.google.gwt.dev.util.Empty;
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
 import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;

 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.core.compiler.IProblem;
 import org.eclipse.jdt.internal.compiler.CompilationResult;
 import org.eclipse.jdt.internal.compiler.Compiler;
 import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
 import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
 import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
 import org.eclipse.jdt.internal.compiler.IProblemFactory;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
 import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
 import org.eclipse.jdt.internal.compiler.env.IBinaryType;
 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
 import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
 import org.eclipse.jdt.internal.compiler.util.Messages;

 import java.net.URL;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;

 /**
  * A facade around the JDT compiler to manage on-demand compilation, caching
  * smartly where possible.
  */
 public abstract class AbstractCompiler {

   /**
    * Contains the results of a compilation run. Includes both the compiled
    * source units and the type bindings for binary types that were looked up
    * during the compilation.
    */
   public static class CompilationResults {
     /**
      * Bindings for binary types looked up during compilation.
      */
     public final Map<String, BinaryTypeBinding> binaryBindings;

     /**
      * Compiled source units.
      */
     public final CompilationUnitDeclaration[] compiledUnits;

     public CompilationResults(CompilationUnitDeclaration[] compiledUnits,
         Map<String, BinaryTypeBinding> binaryBindings) {
       this.compiledUnits = compiledUnits;
       this.binaryBindings = binaryBindings;
     }
   }

   /**
    * Adapts a {@link CompilationUnit} for a JDT compile.
    */
   public static class CompilationUnitAdapter implements ICompilationUnit {

     private final CompilationUnit unit;

     public CompilationUnitAdapter(CompilationUnit unit) {
       this.unit = unit;
     }

     @SuppressWarnings("deprecation")
     public char[] getContents() {
       return unit.getSource().toCharArray();
     }

     public char[] getFileName() {
       return unit.getResourceLocation().toCharArray();
     }

     public char[] getMainTypeName() {
       return Shared.getShortName(unit.getTypeName()).toCharArray();
     }

     public char[][] getPackageName() {
       String packageName = Shared.getPackageName(unit.getTypeName());
       return CharOperation.splitOn('.', packageName.toCharArray());
     }

     @Override
     public String toString() {
       return unit.toString();
     }
   }

   /**
    * Shields {@link AbstractCompiler} so it can be garbage collected at the end
    * of a compile.
    */
   private static class Sandbox {

     /**
      * Adapted to hook the processing of compilation unit declarations so as to
      * be able to add additional compilation units based on the results of
      * previously-compiled ones. Examples of cases where this is useful include
      * classes referenced only from JSNI and <code>GWT.create</code>.
      */
     private class CompilerImpl extends Compiler {

       private Map<String, BinaryTypeBinding> bindings;
       private Set<CompilationUnitDeclaration> cuds;
       private long jdtProcessNanos;

       public CompilerImpl(INameEnvironment environment, IErrorHandlingPolicy policy,
           CompilerOptions compilerOptions, ICompilerRequestor requestor,
           IProblemFactory problemFactory) {
         super(environment, policy, compilerOptions, requestor, problemFactory);
       }

       @Override
       public void accept(IBinaryType binaryType, PackageBinding packageBinding,
           AccessRestriction accessRestriction) {
         // Do the same thing as super.accept(), but record the BinaryTypeBinding
         // that is generated from lookupEnvironment.
         if (this.options.verbose) {
           out.println(Messages.bind(Messages.compilation_loadBinary, new String(binaryType
               .getName())));
         }
         BinaryTypeBinding binding =
             lookupEnvironment.createBinaryTypeFrom(binaryType, packageBinding, accessRestriction);
         String name = CharOperation.toString(binding.compoundName);
         if (bindings != null) {
           bindings.put(name, binding);
         }
       }

       @Override
       public void compile(ICompilationUnit[] sourceUnits) {
         SpeedTracerLogger.Event compileEvent =
             SpeedTracerLogger.start(CompilerEventType.JDT_COMPILER_SANDBOX);
         try {
           super.compile(sourceUnits);
         } finally {
           compileEvent.end();
         }
         cuds = null;
       }

       @Override
       public void process(CompilationUnitDeclaration unit, int index) {

         long processBeginNanos = System.nanoTime();

         // The following block of code is a copy of super.process(cud, index),
         // with the modification that cud.generateCode is conditionally called
         // based on doGenerateBytes
         {
           this.lookupEnvironment.unitBeingCompleted = unit;
           long parseStart = System.currentTimeMillis();

           this.parser.getMethodBodies(unit);

           long resolveStart = System.currentTimeMillis();
           this.stats.parseTime += resolveStart - parseStart;

           // fault in fields & methods
           if (unit.scope != null) {
             unit.scope.faultInTypes();
           }

           // verify inherited methods
           if (unit.scope != null) {
             unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
           }

           // type checking
           unit.resolve();

           long analyzeStart = System.currentTimeMillis();
           this.stats.resolveTime += analyzeStart - resolveStart;

           // flow analysis
           unit.analyseCode();

           long generateStart = System.currentTimeMillis();
           this.stats.analyzeTime += generateStart - analyzeStart;

           // code generation
           if (doGenerateBytes) {
             unit.generateCode();
           }

           // reference info
           if (options.produceReferenceInfo && unit.scope != null) {
             unit.scope.storeDependencyInfo();
           }

           // finalize problems (suppressWarnings)
           unit.finalizeProblems();

           this.stats.generateTime += System.currentTimeMillis() - generateStart;

           // refresh the total number of units known at this stage
           unit.compilationResult.totalUnitsKnown = totalUnits;

           this.lookupEnvironment.unitBeingCompleted = null;
         }

         ICompilationUnit cu = unit.compilationResult.compilationUnit;
         String loc = String.valueOf(cu.getFileName());
         TreeLogger branch =
             logger.branch(TreeLogger.SPAM, "Scanning for additional dependencies: " + loc, null);

         // Examine the cud for types outside of the flow of the original Java
         // source.
         //
         String[] typeNames = outer.doFindAdditionalTypesUsingJsni(branch, unit);
         addAdditionalTypes(branch, typeNames);

         typeNames = outer.doFindAdditionalTypesUsingArtificialRescues(branch, unit);
         addAdditionalTypes(branch, typeNames);

         typeNames = outer.doFindAdditionalTypesUsingRebinds(branch, unit);
         addAdditionalTypes(branch, typeNames);
         if (typeNames.length > 0) {
           refreshPackagesFromCompState();
         }

         // Optionally remember this cud.
         //
         if (cuds != null) {
           cuds.add(unit);
         }

         jdtProcessNanos += System.nanoTime() - processBeginNanos;
       }

       /**
        * Helper method for process() that receives the types found outside the
        * flow of the original Java source. This causes the compiler to find the
        * additional type, possibly causing the type to be compiled from source.
        */
       private void addAdditionalTypes(TreeLogger logger, String[] typeNames) {
         for (String typeName : typeNames) {
           if (logger.isLoggable(TreeLogger.SPAM)) {
             logger.log(TreeLogger.SPAM, "Need additional type '" + typeName + "'", null);
           }

           resolvePossiblyNestedType(typeName);
         }
       }

       private void compile(ICompilationUnit[] units, Set<CompilationUnitDeclaration> cuds,
           Map<String, BinaryTypeBinding> bindings) {
         this.bindings = bindings;
         this.cuds = cuds;
         compile(units);
       }

       private ReferenceBinding resolvePossiblyNestedType(String typeName) {
         return JdtCompiler.resolveType(lookupEnvironment, typeName);
       }
     }

     private class ICompilerRequestorImpl implements ICompilerRequestor {

       public ICompilerRequestorImpl() {
       }

       public void acceptResult(CompilationResult result) {
         // Handle compilation errors.
         //
         IProblem[] errors = result.getErrors();

         if (errors != null && errors.length > 0) {
           // Dump it to disk.
           //
           String fn = String.valueOf(result.compilationUnit.getFileName());
           String msg = "Errors in '" + fn + "'";
           TreeLogger branch = logger.branch(TreeLogger.ERROR, msg, null);

           for (IProblem error : errors) {
             // Strip the initial code from each error.
             //
             msg = error.toString();
             msg = msg.substring(msg.indexOf(' '));

             // Append 'Line #: msg' to the error message.
             //
             StringBuffer msgBuf = new StringBuffer();
             int line = error.getSourceLineNumber();
             if (line > 0) {
               msgBuf.append("Line ");
               msgBuf.append(line);
               msgBuf.append(": ");
             }
             msgBuf.append(msg);

             HelpInfo helpInfo = null;
             if (error instanceof GWTProblem) {
               GWTProblem gwtProblem = (GWTProblem) error;
               helpInfo = gwtProblem.getHelpInfo();
             }
             branch.log(TreeLogger.ERROR, msgBuf.toString(), null, helpInfo);
           }
         }
       }
     }

     private class INameEnvironmentImpl implements INameEnvironment {

       public INameEnvironmentImpl() {
       }

       public void cleanup() {
         // intentionally blank
       }

       public NameEnvironmentAnswer findType(char[] type, char[][] pkg) {
         return findType(CharOperation.arrayConcat(pkg, type));
       }

       public NameEnvironmentAnswer findType(char[][] compoundTypeName) {
         String qname = CharOperation.toString(compoundTypeName);
         TreeLogger branch =
             logger.branch(TreeLogger.SPAM, "Compiler is asking about '" + qname + "'", null);

         if (isPackage(qname)) {
           branch.log(TreeLogger.SPAM, "Found to be a package", null);
           return null;
         }

         // Didn't find it in the cache, so let's compile from source.
         // Strip off the inner types, if any
         //
         String className = qname;
         int pos = qname.indexOf('$');
         if (pos >= 0) {
           qname = qname.substring(0, pos);
         }
         CompilationUnit unit = findCompilationUnit(qname);
         if (unit != null) {
           if (branch.isLoggable(TreeLogger.SPAM)) {
             branch.log(TreeLogger.SPAM, "Found type in compilation unit: "
                 + unit.getResourceLocation());
           }
           ICompilationUnit icu = new CompilationUnitAdapter(unit);
           return new NameEnvironmentAnswer(icu, null);
         } else {
           ClassLoader classLoader = getClassLoader();
           URL resourceURL = classLoader.getResource(className.replace('.', '/') + ".class");
           if (resourceURL != null) {
             /*
              * We know that there is a .class file that matches the name that we
              * are looking for. However, at least on OSX, this lookup is case
              * insensitive so we need to use Class.forName to effectively verify
              * the case.
              */
             if (isBinaryType(classLoader, className)) {
               byte[] classBytes = Util.readURLAsBytes(resourceURL);
               try {
                 ClassFileReader cfr = new ClassFileReader(classBytes, null);
                 return new NameEnvironmentAnswer(cfr, null);
               } catch (ClassFormatException e) {
                 // Ignored.
               }
             }
           }

           branch.log(TreeLogger.SPAM, "Not a known type", null);
           return null;
         }
       }

       public boolean isPackage(char[][] parentPkg, char[] pkg) {
         // In special cases where class bytes are asserted from the outside,
         // a package can exist that the host doesn't know about. We have to
         // do a special check for these cases.
         //
         final char[] pathChars = CharOperation.concatWith(parentPkg, pkg, '.');
         String packageName = String.valueOf(pathChars);
         if (isPackage(packageName)) {
           return true;
         } else if (isPackage(getClassLoader(), packageName)) {
           // Grow our own list to spare calls into the host.
           //
           rememberPackage(packageName);
           return true;
         } else {
           return false;
         }
       }

       private ClassLoader getClassLoader() {
         return Thread.currentThread().getContextClassLoader();
       }

       private boolean isBinaryType(ClassLoader classLoader, String typeName) {
         try {
           Class.forName(typeName, false, classLoader);
           return true;
         } catch (ClassNotFoundException e) {
           // Ignored.
         } catch (LinkageError e) {
           // Ignored.
         }

         // Assume that it is not a binary type.
         return false;
       }

       private boolean isPackage(ClassLoader classLoader, String packageName) {
         String packageAsPath = packageName.replace('.', '/');

         // Test the JRE explicitly, because the classloader trick doesn't work.
         if (JdtCompiler.JreIndex.contains(packageAsPath)) {
           return true;
         }

         return classLoader.getResource(packageAsPath) != null;
       }

       private boolean isPackage(String packageName) {
         return knownPackages.contains(packageName);
       }
     }

     final CompilerImpl compiler;
     final boolean doGenerateBytes;
     final Set<String> knownPackages = new HashSet<String>();
     TreeLogger logger = null;
     AbstractCompiler outer;

     Sandbox(AbstractCompiler outer, boolean doGenerateBytes) {
       this.outer = outer;
       this.doGenerateBytes = doGenerateBytes;
       rememberPackage("");

       INameEnvironment env = new INameEnvironmentImpl();
       IErrorHandlingPolicy pol = DefaultErrorHandlingPolicies.proceedWithAllProblems();
       IProblemFactory probFact = new DefaultProblemFactory(Locale.getDefault());
       ICompilerRequestor req = new ICompilerRequestorImpl();
       CompilerOptions options = getCompilerOptions();

       // This is only needed by TypeOracleBuilder to parse metadata.
       options.docCommentSupport = false;

       compiler = new CompilerImpl(env, pol, options, req, probFact);

       // Initialize the packages list.
       refreshPackagesFromCompState();
     }

     public void clear() {
       outer = null;
       logger = TreeLogger.NULL;
       compiler.bindings = null;
     }

     private CompilationUnit findCompilationUnit(String qname) {
       if (outer == null) {
         return null;
       }

       // Build the initial set of compilation units.
       Map<String, CompilationUnit> unitMap = outer.compilationState.getCompilationUnitMap();
       CompilationUnit unit = unitMap.get(qname);
       while (unit == null) {
         int pos = qname.lastIndexOf('.');
         if (pos < 0) {
           return null;
         }
         qname = qname.substring(0, pos);
         unit = unitMap.get(qname);
       }
       return unit;
     }

     private void refreshPackagesFromCompState() {
       for (CompilationUnit unit : outer.compilationState.getCompilationUnits()) {
         String packageName = Shared.getPackageName(unit.getTypeName());
         rememberPackage(packageName);
       }
     }

     /**
      * Causes the compilation service itself to recognize the specified package
      * name (and all its parent packages), avoiding a call back into the host.
      * This is useful as an optimization, but more importantly, it is useful to
      * compile against bytecode that was pre-compiled to which we don't have the
      * source. This ability is crucial bridging the gap between user-level and
      * "dev" code in Development Mode for classes such as JavaScriptHost and
      * ShellJavaScriptHost.
      */
     private void rememberPackage(String packageName) {
       if (knownPackages.add(packageName)) {
         int i = packageName.lastIndexOf('.');
         if (i != -1) {
           // Ensure the parent package is also created.
           //
           rememberPackage(packageName.substring(0, i));
         }
       }
     }
   }

   private static final Comparator<CompilationUnitDeclaration> CUD_COMPARATOR =
       new Comparator<CompilationUnitDeclaration>() {

         public int compare(CompilationUnitDeclaration cud1, CompilationUnitDeclaration cud2) {
           ICompilationUnit cu1 = cud1.compilationResult().getCompilationUnit();
           ICompilationUnit cu2 = cud2.compilationResult().getCompilationUnit();
           char[][] package1 = cu1.getPackageName();
           char[][] package2 = cu2.getPackageName();
           for (int i = 0, c = Math.min(package1.length, package2.length); i < c; ++i) {
             int result = CharArrayComparator.INSTANCE.compare(package1[i], package2[i]);
             if (result != 0) {
               return result;
             }
           }
           int result = package2.length - package1.length;
           if (result != 0) {
             return result;
           }
           return CharArrayComparator.INSTANCE.compare(cu1.getMainTypeName(), cu2.getMainTypeName());
         }
       };

   public static CompilerOptions getCompilerOptions() {
     CompilerOptions options = JdtCompiler.getCompilerOptions();

     // Turn off all debugging for Production Mode.
     options.produceDebugAttributes = 0;
     options.preserveAllLocalVariables = false;
     return options;
   }

   protected CompilationState compilationState;
   private Sandbox sandbox;

   protected AbstractCompiler(CompilationState compilationState, boolean doGenerateBytes) {
     this.compilationState = compilationState;
     this.sandbox = new Sandbox(this, doGenerateBytes);
   }

   protected final CompilationResults compile(TreeLogger logger, ICompilationUnit[] units) {

     // Any additional compilation units that are found to be needed will be
     // pulled in while processing compilation units. See CompilerImpl.process().
     //
     sandbox.logger = logger;
     try {
       Set<CompilationUnitDeclaration> cuds =
           new TreeSet<CompilationUnitDeclaration>(CUD_COMPARATOR);
       LinkedHashMap<String, BinaryTypeBinding> bindings =
           new LinkedHashMap<String, BinaryTypeBinding>();
       sandbox.compiler.compile(units, cuds, bindings);
       return new CompilationResults(cuds.toArray(new CompilationUnitDeclaration[cuds.size()]),
           bindings);
     } finally {
       sandbox.clear();
       sandbox = null;
     }
   }

   /**
    * @param logger a {@link TreeLogger}
    * @param cud a {@link CompilationUnitDeclaration}
    */
   protected String[] doFindAdditionalTypesUsingArtificialRescues(TreeLogger logger,
       CompilationUnitDeclaration cud) {
     return Empty.STRINGS;
   }

   /**
    * @param logger a {@link TreeLogger}
    * @param cud a {@link CompilationUnitDeclaration}
    */
   protected String[] doFindAdditionalTypesUsingJsni(TreeLogger logger,
       CompilationUnitDeclaration cud) {
     return Empty.STRINGS;
   }

   /**
    * @param logger a {@link TreeLogger}
    * @param cud a {@link CompilationUnitDeclaration}
    */
   protected String[] doFindAdditionalTypesUsingRebinds(TreeLogger logger,
       CompilationUnitDeclaration cud) {
     return Empty.STRINGS;
   }

   protected final ReferenceBinding resolvePossiblyNestedType(String typeName) {
     return sandbox.compiler.resolvePossiblyNestedType(typeName);
   }
 }
	/*
	* Copyright 2008 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License"); you may not
	* use this file except in compliance with the License. You may obtain a copy of
	* the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.gwt.dev.jdt;

	import com.google.gwt.core.ext.TreeLogger;
	import com.google.gwt.core.ext.TreeLogger.HelpInfo;
	import com.google.gwt.dev.javac.CompilationState;
	import com.google.gwt.dev.javac.CompilationUnit;
	import com.google.gwt.dev.javac.GWTProblem;
	import com.google.gwt.dev.javac.JdtCompiler;
	import com.google.gwt.dev.javac.Shared;
	import com.google.gwt.dev.util.CharArrayComparator;
	import com.google.gwt.dev.util.Empty;
	import com.google.gwt.dev.util.Util;
	import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
	import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;

	import org.eclipse.jdt.core.compiler.CharOperation;
	import org.eclipse.jdt.core.compiler.IProblem;
	import org.eclipse.jdt.internal.compiler.CompilationResult;
	import org.eclipse.jdt.internal.compiler.Compiler;
	import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
	import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
	import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
	import org.eclipse.jdt.internal.compiler.IProblemFactory;
	import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
	import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
	import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
	import org.eclipse.jdt.internal.compiler.env.IBinaryType;
	import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
	import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
	import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
	import org.eclipse.jdt.internal.compiler.lookup.BinaryTypeBinding;
	import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
	import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
	import org.eclipse.jdt.internal.compiler.util.Messages;

	import java.net.URL;
	import java.util.Comparator;
	import java.util.HashSet;
	import java.util.LinkedHashMap;
	import java.util.Locale;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeSet;

	/**
	* A facade around the JDT compiler to manage on-demand compilation, caching
	* smartly where possible.
	*/
	public abstract class AbstractCompiler {

	/**
	* Contains the results of a compilation run. Includes both the compiled
	* source units and the type bindings for binary types that were looked up
	* during the compilation.
	*/
	public static class CompilationResults {
	/**
	* Bindings for binary types looked up during compilation.
	*/
	public final Map<String, BinaryTypeBinding> binaryBindings;

	/**
	* Compiled source units.
	*/
	public final CompilationUnitDeclaration[] compiledUnits;

	public CompilationResults(CompilationUnitDeclaration[] compiledUnits,
	Map<String, BinaryTypeBinding> binaryBindings) {
	this.compiledUnits = compiledUnits;
	this.binaryBindings = binaryBindings;
	}
	}

	/**
	* Adapts a {@link CompilationUnit} for a JDT compile.
	*/
	public static class CompilationUnitAdapter implements ICompilationUnit {

	private final CompilationUnit unit;

	public CompilationUnitAdapter(CompilationUnit unit) {
	this.unit = unit;
	}

	@SuppressWarnings("deprecation")
	public char[] getContents() {
	return unit.getSource().toCharArray();
	}

	public char[] getFileName() {
	return unit.getResourceLocation().toCharArray();
	}

	public char[] getMainTypeName() {
	return Shared.getShortName(unit.getTypeName()).toCharArray();
	}

	public char[][] getPackageName() {
	String packageName = Shared.getPackageName(unit.getTypeName());
	return CharOperation.splitOn('.', packageName.toCharArray());
	}

	@Override
	public String toString() {
	return unit.toString();
	}
	}

	/**
	* Shields {@link AbstractCompiler} so it can be garbage collected at the end
	* of a compile.
	*/
	private static class Sandbox {

	/**
	* Adapted to hook the processing of compilation unit declarations so as to
	* be able to add additional compilation units based on the results of
	* previously-compiled ones. Examples of cases where this is useful include
	* classes referenced only from JSNI and <code>GWT.create</code>.
	*/
	private class CompilerImpl extends Compiler {

	private Map<String, BinaryTypeBinding> bindings;
	private Set<CompilationUnitDeclaration> cuds;
	private long jdtProcessNanos;

	public CompilerImpl(INameEnvironment environment, IErrorHandlingPolicy policy,
	CompilerOptions compilerOptions, ICompilerRequestor requestor,
	IProblemFactory problemFactory) {
	super(environment, policy, compilerOptions, requestor, problemFactory);
	}

	@Override
	public void accept(IBinaryType binaryType, PackageBinding packageBinding,
	AccessRestriction accessRestriction) {
	// Do the same thing as super.accept(), but record the BinaryTypeBinding
	// that is generated from lookupEnvironment.
	if (this.options.verbose) {
	out.println(Messages.bind(Messages.compilation_loadBinary, new String(binaryType
	.getName())));
	}
	BinaryTypeBinding binding =
	lookupEnvironment.createBinaryTypeFrom(binaryType, packageBinding, accessRestriction);
	String name = CharOperation.toString(binding.compoundName);
	if (bindings != null) {
	bindings.put(name, binding);
	}
	}

	@Override
	public void compile(ICompilationUnit[] sourceUnits) {
	SpeedTracerLogger.Event compileEvent =
	SpeedTracerLogger.start(CompilerEventType.JDT_COMPILER_SANDBOX);
	try {
	super.compile(sourceUnits);
	} finally {
	compileEvent.end();
	}
	cuds = null;
	}

	@Override
	public void process(CompilationUnitDeclaration unit, int index) {

	long processBeginNanos = System.nanoTime();

	// The following block of code is a copy of super.process(cud, index),
	// with the modification that cud.generateCode is conditionally called
	// based on doGenerateBytes
	{
	this.lookupEnvironment.unitBeingCompleted = unit;
	long parseStart = System.currentTimeMillis();

	this.parser.getMethodBodies(unit);

	long resolveStart = System.currentTimeMillis();
	this.stats.parseTime += resolveStart - parseStart;

	// fault in fields & methods
	if (unit.scope != null) {
	unit.scope.faultInTypes();
	}

	// verify inherited methods
	if (unit.scope != null) {
	unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
	}

	// type checking
	unit.resolve();

	long analyzeStart = System.currentTimeMillis();
	this.stats.resolveTime += analyzeStart - resolveStart;

	// flow analysis
	unit.analyseCode();

	long generateStart = System.currentTimeMillis();
	this.stats.analyzeTime += generateStart - analyzeStart;

	// code generation
	if (doGenerateBytes) {
	unit.generateCode();
	}

	// reference info
	if (options.produceReferenceInfo && unit.scope != null) {
	unit.scope.storeDependencyInfo();
	}

	// finalize problems (suppressWarnings)
	unit.finalizeProblems();

	this.stats.generateTime += System.currentTimeMillis() - generateStart;

	// refresh the total number of units known at this stage
	unit.compilationResult.totalUnitsKnown = totalUnits;

	this.lookupEnvironment.unitBeingCompleted = null;
	}

	ICompilationUnit cu = unit.compilationResult.compilationUnit;
	String loc = String.valueOf(cu.getFileName());
	TreeLogger branch =
	logger.branch(TreeLogger.SPAM, "Scanning for additional dependencies: " + loc, null);

	// Examine the cud for types outside of the flow of the original Java
	// source.
	//
	String[] typeNames = outer.doFindAdditionalTypesUsingJsni(branch, unit);
	addAdditionalTypes(branch, typeNames);

	typeNames = outer.doFindAdditionalTypesUsingArtificialRescues(branch, unit);
	addAdditionalTypes(branch, typeNames);

	typeNames = outer.doFindAdditionalTypesUsingRebinds(branch, unit);
	addAdditionalTypes(branch, typeNames);
	if (typeNames.length > 0) {
	refreshPackagesFromCompState();
	}

	// Optionally remember this cud.
	//
	if (cuds != null) {
	cuds.add(unit);
	}

	jdtProcessNanos += System.nanoTime() - processBeginNanos;
	}

	/**
	* Helper method for process() that receives the types found outside the
	* flow of the original Java source. This causes the compiler to find the
	* additional type, possibly causing the type to be compiled from source.
	*/
	private void addAdditionalTypes(TreeLogger logger, String[] typeNames) {
	for (String typeName : typeNames) {
	if (logger.isLoggable(TreeLogger.SPAM)) {
	logger.log(TreeLogger.SPAM, "Need additional type '" + typeName + "'", null);
	}

	resolvePossiblyNestedType(typeName);
	}
	}

	private void compile(ICompilationUnit[] units, Set<CompilationUnitDeclaration> cuds,
	Map<String, BinaryTypeBinding> bindings) {
	this.bindings = bindings;
	this.cuds = cuds;
	compile(units);
	}

	private ReferenceBinding resolvePossiblyNestedType(String typeName) {
	return JdtCompiler.resolveType(lookupEnvironment, typeName);
	}
	}

	private class ICompilerRequestorImpl implements ICompilerRequestor {

	public ICompilerRequestorImpl() {
	}

	public void acceptResult(CompilationResult result) {
	// Handle compilation errors.
	//
	IProblem[] errors = result.getErrors();

	if (errors != null && errors.length > 0) {
	// Dump it to disk.
	//
	String fn = String.valueOf(result.compilationUnit.getFileName());
	String msg = "Errors in '" + fn + "'";
	TreeLogger branch = logger.branch(TreeLogger.ERROR, msg, null);

	for (IProblem error : errors) {
	// Strip the initial code from each error.
	//
	msg = error.toString();
	msg = msg.substring(msg.indexOf(' '));

	// Append 'Line #: msg' to the error message.
	//
	StringBuffer msgBuf = new StringBuffer();
	int line = error.getSourceLineNumber();
	if (line > 0) {
	msgBuf.append("Line ");
	msgBuf.append(line);
	msgBuf.append(": ");
	}
	msgBuf.append(msg);

	HelpInfo helpInfo = null;
	if (error instanceof GWTProblem) {
	GWTProblem gwtProblem = (GWTProblem) error;
	helpInfo = gwtProblem.getHelpInfo();
	}
	branch.log(TreeLogger.ERROR, msgBuf.toString(), null, helpInfo);
	}
	}
	}
	}

	private class INameEnvironmentImpl implements INameEnvironment {

	public INameEnvironmentImpl() {
	}

	public void cleanup() {
	// intentionally blank
	}

	public NameEnvironmentAnswer findType(char[] type, char[][] pkg) {
	return findType(CharOperation.arrayConcat(pkg, type));
	}

	public NameEnvironmentAnswer findType(char[][] compoundTypeName) {
	String qname = CharOperation.toString(compoundTypeName);
	TreeLogger branch =
	logger.branch(TreeLogger.SPAM, "Compiler is asking about '" + qname + "'", null);

	if (isPackage(qname)) {
	branch.log(TreeLogger.SPAM, "Found to be a package", null);
	return null;
	}

	// Didn't find it in the cache, so let's compile from source.
	// Strip off the inner types, if any
	//
	String className = qname;
	int pos = qname.indexOf('$');
	if (pos >= 0) {
	qname = qname.substring(0, pos);
	}
	CompilationUnit unit = findCompilationUnit(qname);
	if (unit != null) {
	if (branch.isLoggable(TreeLogger.SPAM)) {
	branch.log(TreeLogger.SPAM, "Found type in compilation unit: "
	+ unit.getResourceLocation());
	}
	ICompilationUnit icu = new CompilationUnitAdapter(unit);
	return new NameEnvironmentAnswer(icu, null);
	} else {
	ClassLoader classLoader = getClassLoader();
	URL resourceURL = classLoader.getResource(className.replace('.', '/') + ".class");
	if (resourceURL != null) {
	/*
	* We know that there is a .class file that matches the name that we
	* are looking for. However, at least on OSX, this lookup is case
	* insensitive so we need to use Class.forName to effectively verify
	* the case.
	*/
	if (isBinaryType(classLoader, className)) {
	byte[] classBytes = Util.readURLAsBytes(resourceURL);
	try {
	ClassFileReader cfr = new ClassFileReader(classBytes, null);
	return new NameEnvironmentAnswer(cfr, null);
	} catch (ClassFormatException e) {
	// Ignored.
	}
	}
	}

	branch.log(TreeLogger.SPAM, "Not a known type", null);
	return null;
	}
	}

	public boolean isPackage(char[][] parentPkg, char[] pkg) {
	// In special cases where class bytes are asserted from the outside,
	// a package can exist that the host doesn't know about. We have to
	// do a special check for these cases.
	//
	final char[] pathChars = CharOperation.concatWith(parentPkg, pkg, '.');
	String packageName = String.valueOf(pathChars);
	if (isPackage(packageName)) {
	return true;
	} else if (isPackage(getClassLoader(), packageName)) {
	// Grow our own list to spare calls into the host.
	//
	rememberPackage(packageName);
	return true;
	} else {
	return false;
	}
	}

	private ClassLoader getClassLoader() {
	return Thread.currentThread().getContextClassLoader();
	}

	private boolean isBinaryType(ClassLoader classLoader, String typeName) {
	try {
	Class.forName(typeName, false, classLoader);
	return true;
	} catch (ClassNotFoundException e) {
	// Ignored.
	} catch (LinkageError e) {
	// Ignored.
	}

	// Assume that it is not a binary type.
	return false;
	}

	private boolean isPackage(ClassLoader classLoader, String packageName) {
	String packageAsPath = packageName.replace('.', '/');

	// Test the JRE explicitly, because the classloader trick doesn't work.
	if (JdtCompiler.JreIndex.contains(packageAsPath)) {
	return true;
	}

	return classLoader.getResource(packageAsPath) != null;
	}

	private boolean isPackage(String packageName) {
	return knownPackages.contains(packageName);
	}
	}

	final CompilerImpl compiler;
	final boolean doGenerateBytes;
	final Set<String> knownPackages = new HashSet<String>();
	TreeLogger logger = null;
	AbstractCompiler outer;

	Sandbox(AbstractCompiler outer, boolean doGenerateBytes) {
	this.outer = outer;
	this.doGenerateBytes = doGenerateBytes;
	rememberPackage("");

	INameEnvironment env = new INameEnvironmentImpl();
	IErrorHandlingPolicy pol = DefaultErrorHandlingPolicies.proceedWithAllProblems();
	IProblemFactory probFact = new DefaultProblemFactory(Locale.getDefault());
	ICompilerRequestor req = new ICompilerRequestorImpl();
	CompilerOptions options = getCompilerOptions();

	// This is only needed by TypeOracleBuilder to parse metadata.
	options.docCommentSupport = false;

	compiler = new CompilerImpl(env, pol, options, req, probFact);

	// Initialize the packages list.
	refreshPackagesFromCompState();
	}

	public void clear() {
	outer = null;
	logger = TreeLogger.NULL;
	compiler.bindings = null;
	}

	private CompilationUnit findCompilationUnit(String qname) {
	if (outer == null) {
	return null;
	}

	// Build the initial set of compilation units.
	Map<String, CompilationUnit> unitMap = outer.compilationState.getCompilationUnitMap();
	CompilationUnit unit = unitMap.get(qname);
	while (unit == null) {
	int pos = qname.lastIndexOf('.');
	if (pos < 0) {
	return null;
	}
	qname = qname.substring(0, pos);
	unit = unitMap.get(qname);
	}
	return unit;
	}

	private void refreshPackagesFromCompState() {
	for (CompilationUnit unit : outer.compilationState.getCompilationUnits()) {
	String packageName = Shared.getPackageName(unit.getTypeName());
	rememberPackage(packageName);
	}
	}

	/**
	* Causes the compilation service itself to recognize the specified package
	* name (and all its parent packages), avoiding a call back into the host.
	* This is useful as an optimization, but more importantly, it is useful to
	* compile against bytecode that was pre-compiled to which we don't have the
	* source. This ability is crucial bridging the gap between user-level and
	* "dev" code in Development Mode for classes such as JavaScriptHost and
	* ShellJavaScriptHost.
	*/
	private void rememberPackage(String packageName) {
	if (knownPackages.add(packageName)) {
	int i = packageName.lastIndexOf('.');
	if (i != -1) {
	// Ensure the parent package is also created.
	//
	rememberPackage(packageName.substring(0, i));
	}
	}
	}
	}

	private static final Comparator<CompilationUnitDeclaration> CUD_COMPARATOR =
	new Comparator<CompilationUnitDeclaration>() {

	public int compare(CompilationUnitDeclaration cud1, CompilationUnitDeclaration cud2) {
	ICompilationUnit cu1 = cud1.compilationResult().getCompilationUnit();
	ICompilationUnit cu2 = cud2.compilationResult().getCompilationUnit();
	char[][] package1 = cu1.getPackageName();
	char[][] package2 = cu2.getPackageName();
	for (int i = 0, c = Math.min(package1.length, package2.length); i < c; ++i) {
	int result = CharArrayComparator.INSTANCE.compare(package1[i], package2[i]);
	if (result != 0) {
	return result;
	}
	}
	int result = package2.length - package1.length;
	if (result != 0) {
	return result;
	}
	return CharArrayComparator.INSTANCE.compare(cu1.getMainTypeName(), cu2.getMainTypeName());
	}
	};

	public static CompilerOptions getCompilerOptions() {
	CompilerOptions options = JdtCompiler.getCompilerOptions();

	// Turn off all debugging for Production Mode.
	options.produceDebugAttributes = 0;
	options.preserveAllLocalVariables = false;
	return options;
	}

	protected CompilationState compilationState;
	private Sandbox sandbox;

	protected AbstractCompiler(CompilationState compilationState, boolean doGenerateBytes) {
	this.compilationState = compilationState;
	this.sandbox = new Sandbox(this, doGenerateBytes);
	}

	protected final CompilationResults compile(TreeLogger logger, ICompilationUnit[] units) {

	// Any additional compilation units that are found to be needed will be
	// pulled in while processing compilation units. See CompilerImpl.process().
	//
	sandbox.logger = logger;
	try {
	Set<CompilationUnitDeclaration> cuds =
	new TreeSet<CompilationUnitDeclaration>(CUD_COMPARATOR);
	LinkedHashMap<String, BinaryTypeBinding> bindings =
	new LinkedHashMap<String, BinaryTypeBinding>();
	sandbox.compiler.compile(units, cuds, bindings);
	return new CompilationResults(cuds.toArray(new CompilationUnitDeclaration[cuds.size()]),
	bindings);
	} finally {
	sandbox.clear();
	sandbox = null;
	}
	}

	/**
	* @param logger a {@link TreeLogger}
	* @param cud a {@link CompilationUnitDeclaration}
	*/
	protected String[] doFindAdditionalTypesUsingArtificialRescues(TreeLogger logger,
	CompilationUnitDeclaration cud) {
	return Empty.STRINGS;
	}

	/**
	* @param logger a {@link TreeLogger}
	* @param cud a {@link CompilationUnitDeclaration}
	*/
	protected String[] doFindAdditionalTypesUsingJsni(TreeLogger logger,
	CompilationUnitDeclaration cud) {
	return Empty.STRINGS;
	}

	/**
	* @param logger a {@link TreeLogger}
	* @param cud a {@link CompilationUnitDeclaration}
	*/
	protected String[] doFindAdditionalTypesUsingRebinds(TreeLogger logger,
	CompilationUnitDeclaration cud) {
	return Empty.STRINGS;
	}

	protected final ReferenceBinding resolvePossiblyNestedType(String typeName) {
	return sandbox.compiler.resolvePossiblyNestedType(typeName);
	}
	}