/*
 * 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.javac;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.dev.javac.asm.CollectAnnotationData;
import com.google.gwt.dev.javac.asm.CollectAnnotationData.AnnotationData;
import com.google.gwt.dev.javac.asm.CollectClassData;
import com.google.gwt.dev.javac.asm.CollectClassData.AnnotationEnum;
import com.google.gwt.dev.javac.asm.CollectFieldData;
import com.google.gwt.dev.javac.asm.CollectMethodData;
import com.google.gwt.dev.javac.asm.CollectTypeParams;
import com.google.gwt.dev.javac.asm.ResolveClassSignature;
import com.google.gwt.dev.javac.asm.ResolveMethodSignature;
import com.google.gwt.dev.javac.asm.ResolveTypeSignature;
import com.google.gwt.dev.javac.typemodel.JAbstractMethod;
import com.google.gwt.dev.javac.typemodel.JArrayType;
import com.google.gwt.dev.javac.typemodel.JClassType;
import com.google.gwt.dev.javac.typemodel.JField;
import com.google.gwt.dev.javac.typemodel.JGenericType;
import com.google.gwt.dev.javac.typemodel.JMethod;
import com.google.gwt.dev.javac.typemodel.JPackage;
import com.google.gwt.dev.javac.typemodel.JParameterizedType;
import com.google.gwt.dev.javac.typemodel.JRawType;
import com.google.gwt.dev.javac.typemodel.JRealClassType;
import com.google.gwt.dev.javac.typemodel.JTypeParameter;
import com.google.gwt.dev.javac.typemodel.JWildcardType;
import com.google.gwt.dev.javac.typemodel.TypeOracle;
import com.google.gwt.dev.javac.typemodel.TypeOracleUpdater;
import com.google.gwt.dev.util.Name;
import com.google.gwt.dev.util.log.speedtracer.CompilerEventType;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger;
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event;
import com.google.gwt.thirdparty.guava.common.annotations.VisibleForTesting;
import com.google.gwt.thirdparty.guava.common.base.Function;
import com.google.gwt.thirdparty.guava.common.collect.Collections2;
import com.google.gwt.thirdparty.guava.common.collect.ImmutableMap;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Maps;
import com.google.gwt.thirdparty.guava.common.collect.Queues;
import com.google.gwt.thirdparty.guava.common.collect.Sets;
import com.google.gwt.thirdparty.guava.common.util.concurrent.ThreadFactoryBuilder;

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.signature.SignatureReader;
import org.objectweb.asm.util.TraceClassVisitor;

import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Builds or rebuilds a {@link com.google.gwt.core.ext.typeinfo.TypeOracle} from a set of
 * compilation units.
 */
public class CompilationUnitTypeOracleUpdater extends TypeOracleUpdater {

  /**
   * A container to hold all the information we need to add one type to the TypeOracle.
   */
  static class TypeData {

    private final byte[] byteCode;
    private CollectClassData classData;
    private final String internalName;

    /**
     * A timestamp as returned from {@link System#currentTimeMillis()}
     */
    private final long lastModifiedTime;
    private final String packageName;
    private final String sourceName;

    protected TypeData(String packageName, String sourceName, String internalName, byte[] byteCode,
        long lastModifiedTime) {
      this.packageName = packageName;
      this.sourceName = sourceName;
      this.internalName = internalName;
      this.byteCode = byteCode;
      this.lastModifiedTime = lastModifiedTime;
    }

    /**
     * Collects data about a class which only needs the bytecode and no TypeOracle data structures.
     * This is used to make the initial shallow identity pass for creating
     * JRealClassType/JGenericType objects.
     */
    synchronized CollectClassData getCollectClassData() {
      if (classData == null) {
        ClassReader reader = new ClassReader(byteCode);
        classData = new CollectClassData();
        ClassVisitor classVisitor = classData;
        if (TRACE_CLASSES) {
          classVisitor = new TraceClassVisitor(classVisitor, new PrintWriter(System.out));
        }
        reader.accept(classVisitor, 0);
      }
      return classData;
    }
  }

  private class CompilationUnitTypeOracleResolver implements Resolver {

    private final TypeOracleBuildContext context;

    public CompilationUnitTypeOracleResolver(TypeOracleBuildContext context) {
      this.context = context;
    }

    @Override
    public void addImplementedInterface(JRealClassType type, JClassType intf) {
      CompilationUnitTypeOracleUpdater.this.addImplementedInterface(type, intf);
    }

    @Override
    public void addThrows(JAbstractMethod method, JClassType exception) {
      CompilationUnitTypeOracleUpdater.this.addThrows(method, exception);
    }

    @Override
    public JRealClassType findByInternalName(String internalName) {
      return CompilationUnitTypeOracleUpdater.this.findByInternalName(internalName);
    }

    @Override
    public TypeOracle getTypeOracle() {
      return CompilationUnitTypeOracleUpdater.this.typeOracle;
    }

    @Override
    public JMethod newMethod(JClassType type, String name,
        Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
        JTypeParameter[] typeParams) {
      return CompilationUnitTypeOracleUpdater.this.newMethod(
          type, name, declaredAnnotations, typeParams);
    }

    @Override
    public void newParameter(JAbstractMethod method, JType argType, String argName,
        Map<Class<? extends Annotation>, Annotation> declaredAnnotations, boolean argNamesAreReal) {
      CompilationUnitTypeOracleUpdater.this.newParameter(
          method, argType, argName, declaredAnnotations, argNamesAreReal);
    }

    @Override
    public JRealClassType newRealClassType(JPackage pkg, String enclosingTypeName,
        boolean isLocalType, String simpleSourceName, boolean isInterface) {
      return CompilationUnitTypeOracleUpdater.this.newRealClassType(
          pkg, enclosingTypeName, simpleSourceName, isInterface);
    }

    @Override
    public boolean resolveAnnotations(TreeLogger logger, List<CollectAnnotationData> annotations,
        Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
      return CompilationUnitTypeOracleUpdater.this.resolveAnnotations(
          logger, annotations, declaredAnnotations);
    }

    @Override
    public boolean resolveClass(TreeLogger logger, JRealClassType type) {
      return CompilationUnitTypeOracleUpdater.this.resolveClass(logger, type, context);
    }

    @Override
    public void setReturnType(JAbstractMethod method, JType returnType) {
      CompilationUnitTypeOracleUpdater.this.setReturnType(method, returnType);
    }

    @Override
    public void setSuperClass(JRealClassType type, JClassType superType) {
      CompilationUnitTypeOracleUpdater.this.setSuperClass(type, superType);
    }
  }

  /**
   * This context keeps common data so we don't have to pass it around between methods for one pass
   * of {@link CompilationUnitTypeOracleUpdater#addNewTypesDontIndex(TreeLogger, Collection,
   * MethodArgNamesLookup)} .
   */
  protected class TypeOracleBuildContext {
    protected final MethodArgNamesLookup allMethodArgs;

    private final Map<String, CollectClassData> classDataByInternalName = Maps.newHashMap();

    private final Map<JRealClassType, CollectClassData> classDataByType = Maps.newHashMap();

    private final Resolver resolver = new CompilationUnitTypeOracleResolver(this);

    protected TypeOracleBuildContext(MethodArgNamesLookup allMethodArgs) {
      this.allMethodArgs = allMethodArgs;
    }
  }

  /**
   * Pairs of bits to convert from ASM Opcodes.* to Shared.* bitfields.
   */
  private static final int[] ASM_TO_SHARED_MODIFIERS =
      new int[] {Opcodes.ACC_PUBLIC, Shared.MOD_PUBLIC, //
          Opcodes.ACC_PRIVATE, Shared.MOD_PRIVATE, //
          Opcodes.ACC_PROTECTED, Shared.MOD_PROTECTED, //
          Opcodes.ACC_STATIC, Shared.MOD_STATIC, //
          Opcodes.ACC_FINAL, Shared.MOD_FINAL, //
          Opcodes.ACC_ABSTRACT, Shared.MOD_ABSTRACT, //
          Opcodes.ACC_VOLATILE, Shared.MOD_VOLATILE, //
          Opcodes.ACC_TRANSIENT, Shared.MOD_TRANSIENT, //
      };

  private static final JTypeParameter[] NO_TYPE_PARAMETERS = new JTypeParameter[0];

  /**
   * Turn on to trace class processing.
   */
  private static final boolean TRACE_CLASSES = false;

  /**
   * Suppress some warnings related to missing valiation.jar on classpath.
   */
  private static boolean warnedMissingValidationJar = false;

  private static JTypeParameter[] collectTypeParams(String signature) {
    if (signature != null) {
      List<JTypeParameter> params = Lists.newArrayList();
      SignatureReader reader = new SignatureReader(signature);
      reader.accept(new CollectTypeParams(params));
      return params.toArray(new JTypeParameter[params.size()]);
    }
    return NO_TYPE_PARAMETERS;
  }

  private static JTypeParameter[] getTypeParametersForClass(CollectClassData classData) {
    JTypeParameter[] typeParams = null;
    if (classData.getSignature() != null) {
      // TODO(jat): do we need to consider generic types w/ method type
      // params for local classes?
      typeParams = collectTypeParams(classData.getSignature());
    }
    return typeParams;
  }

  private static Class<?> getWrapperClass(Class<?> primitiveClass) {
    assert primitiveClass.isPrimitive();
    if (primitiveClass.equals(Integer.TYPE)) {
      return Integer.class;
    } else if (primitiveClass.equals(Boolean.TYPE)) {
      return Boolean.class;
    } else if (primitiveClass.equals(Byte.TYPE)) {
      return Byte.class;
    } else if (primitiveClass.equals(Character.TYPE)) {
      return Character.class;
    } else if (primitiveClass.equals(Short.TYPE)) {
      return Short.class;
    } else if (primitiveClass.equals(Long.TYPE)) {
      return Long.class;
    } else if (primitiveClass.equals(Float.TYPE)) {
      return Float.class;
    } else if (primitiveClass.equals(Double.TYPE)) {
      return Double.class;
    } else {
      throw new IllegalArgumentException(primitiveClass.toString() + " not a primitive class");
    }
  }

  /**
   * Returns whether this name is the special package-info type name.
   */
  private static boolean isPackageInfoTypeName(String simpleSourceName) {
    return "package-info".equals(simpleSourceName);
  }

  /**
   * Returns true if this class is a non-static class inside a generic class.
   */
  // TODO(jat): do we need to consider the entire hierarchy?
  private static boolean nonStaticInsideGeneric(
      CollectClassData classData, CollectClassData enclosingClassData) {
    if (enclosingClassData == null || (classData.getAccess() & Opcodes.ACC_STATIC) != 0) {
      return false;
    }
    return getTypeParametersForClass(enclosingClassData) != null;
  }

  /**
   * Returns the original type or its raw type if it is generic
   */
  private static JType possiblySubstituteRawType(JType type) {
    if (type != null) {
      JGenericType genericType = (JGenericType) type.isGenericType();
      if (genericType != null) {
        type = genericType.getRawType();
      }
    }
    return type;
  }

  private final Set<String> resolvedTypeSourceNames = Sets.newHashSet();
  private final Map<String, JRealClassType> typesByInternalName = Maps.newHashMap();
  /**
   * An executor service to parallelize some of the update process.
   */
  private static ExecutorService executor =
      new ThreadPoolExecutor(0, Runtime.getRuntime().availableProcessors(), 60L, TimeUnit.SECONDS,
          Queues.<Runnable>newLinkedBlockingQueue(),
          // Make sure this executor lets the whole process terminate correctly even if there
          // are still live threads.
          new ThreadFactoryBuilder().setDaemon(true).build());

  public CompilationUnitTypeOracleUpdater(TypeOracle typeOracle) {
    super(typeOracle);
  }

  /**
   * Adds new units to an existing TypeOracle but does not yet index their type hierarchy.<br />
   *
   * It is ok for this function to recursive since no repeated or invalid type indexing will result.
   *
   * @param logger logger to use
   * @param typeDataList collection of data need to build types. (Doesn't retain references to
   *          TypeData instances.)
   * @param argsLookup Allows the caller to pass the method argument names which are not normally
   *          available in bytecode.
   */
  void addNewTypesDontIndex(
      TreeLogger logger, Collection<TypeData> typeDataList, MethodArgNamesLookup argsLookup) {
    Event typeOracleUpdaterEvent = SpeedTracerLogger.start(CompilerEventType.TYPE_ORACLE_UPDATER);

    // First collect all class data.
    Event visitClassFileEvent = SpeedTracerLogger.start(
        CompilerEventType.TYPE_ORACLE_UPDATER, "phase", "Visit Class Files");
    TypeOracleBuildContext context = getContext(argsLookup);

    for (TypeData typeData : typeDataList) {
      CollectClassData classData = typeData.getCollectClassData();
      // skip any classes that can't be referenced by name outside of
      // their local scope, such as anonymous classes and method-local classes
      if (classData.hasNoExternalName()) {
        continue;
      }
      // skip classes that have been previously added
      if (typesByInternalName.containsKey(classData.getInternalName())) {
        continue;
      }
      context.classDataByInternalName.put(typeData.internalName, classData);
    }
    visitClassFileEvent.end();

    Event identityEvent = SpeedTracerLogger.start(
        CompilerEventType.TYPE_ORACLE_UPDATER, "phase", "Establish Identity");
    // Perform a shallow pass to establish identity for new and old types.
    Set<JRealClassType> unresolvedTypes = Sets.newLinkedHashSet();
    for (TypeData typeData : typeDataList) {
      CollectClassData classData = context.classDataByInternalName.get(typeData.internalName);
      if (classData == null) {
        // ignore classes that were skipped earlier
        continue;
      }
      if (typesByInternalName.containsKey(classData.getInternalName())) {
        // skip classes that have been previously added
        continue;
      }
      JRealClassType type = createType(typeData, unresolvedTypes, context);
      if (type != null) {
        assert Name.isInternalName(typeData.internalName);
        typesByInternalName.put(typeData.internalName, type);
        context.classDataByType.put(type, classData);
      }
    }
    identityEvent.end();

    Event resolveEnclosingEvent = SpeedTracerLogger.start(
        CompilerEventType.TYPE_ORACLE_UPDATER, "phase", "Resolve Enclosing Classes");
    // Hook up enclosing types
    TreeLogger branch = logger.branch(TreeLogger.SPAM, "Resolving enclosing classes");
    for (Iterator<JRealClassType> unresolvedTypesIterator = unresolvedTypes.iterator();
        unresolvedTypesIterator.hasNext();) {
      JRealClassType unresolvedType = unresolvedTypesIterator.next();
      if (!resolveEnclosingClass(branch, unresolvedType, context)) {
        // already logged why it failed, don't try and use it further
        unresolvedTypesIterator.remove();
      }
    }
    resolveEnclosingEvent.end();

    Event resolveUnresolvedEvent = SpeedTracerLogger.start(
        CompilerEventType.TYPE_ORACLE_UPDATER, "phase", "Resolve Unresolved Types");
    // Resolve unresolved types.
    for (JRealClassType unresolvedType : unresolvedTypes) {
      branch =
          logger.branch(TreeLogger.SPAM, "Resolving " + unresolvedType.getQualifiedSourceName());
      if (!resolveClass(branch, unresolvedType, context)) {
        // already logged why it failed.
        // TODO: should we do anything else here?
      }
    }
    resolveUnresolvedEvent.end();

    // no longer needed
    context = null;
    typeOracleUpdaterEvent.end();
  }

  private static void prefechTypeData(Collection<TypeData> typeDataList) {
    // Parse bytecode in parallel by calling {@code TypeData.getCollectClassData()} in parallel.
    try {
      executor.<Void>invokeAll(Collections2.transform(typeDataList,
          new Function<TypeData, Callable<Void>>() {
            @Override
            public Callable<Void> apply(final TypeData typeData) {
              return new Callable<Void>() {
                @Override
                public Void call() {
                  typeData.getCollectClassData();
                  return null;
                }
              };
            }
          }));
    } catch (InterruptedException e) {
      // InterruptedException can be safely ignored here as the threads interrupted are only
      // precomputing data in parallel that will otherwise be computed later sequentially if
      // the threads are aborted.
      // Anyway restore the thread interrupted state just in case.
      Thread.currentThread().interrupt();
    }
  }

  /**
   * Adds new units to an existing TypeOracle and indexes their type hierarchy.
   */
  public void addNewUnits(TreeLogger logger, Collection<CompilationUnit> compilationUnits) {
    addNewTypesDontIndex(logger, compilationUnits);
    indexTypes();
  }

  @VisibleForTesting
  void indexTypes() {
    Event finishEvent =
        SpeedTracerLogger.start(CompilerEventType.TYPE_ORACLE_UPDATER, "phase", "Finish");
    super.finish();
    finishEvent.end();
  }

  protected void addNewTypesDontIndex(TreeLogger logger,
      Collection<CompilationUnit> compilationUnits) {
    Collection<TypeData> typeDataList = Lists.newArrayList();

    // Create method args data for types to add
    MethodArgNamesLookup argsLookup = new MethodArgNamesLookup();
    for (CompilationUnit compilationUnit : compilationUnits) {
      argsLookup.mergeFrom(compilationUnit.getMethodArgs());
    }

    // Create list including byte code for each type to add
    // TODO(rluble): this process can be done in parallel. Probably best to merge this for
    // loop with the one in prefetchTypeData.
    for (CompilationUnit compilationUnit : compilationUnits) {
      for (CompiledClass compiledClass : compilationUnit.getCompiledClasses()) {
        TypeData typeData = new TypeData(compiledClass.getPackageName(),
            compiledClass.getSourceName(), compiledClass.getInternalName(),
            compiledClass.getBytes(), compiledClass.getUnit().getLastModified());
        typeDataList.add(typeData);
      }
    }

    prefechTypeData(typeDataList);

    // Add the new types to the type oracle build in progress.
    addNewTypesDontIndex(logger, typeDataList, argsLookup);
  }

  @VisibleForTesting
  public Resolver getMockResolver() {
    return new CompilationUnitTypeOracleResolver(
        new TypeOracleBuildContext(new MethodArgNamesLookup()));
  }

  public TypeOracle getTypeOracle() {
    return typeOracle;
  }

  @VisibleForTesting
  public Map<String, JRealClassType> getTypesByInternalName() {
    return typesByInternalName;
  }

  /**
   * Returns the type corresponding to the given internal name.<br />
   *
   * Implementations are free to service requests eagerly or lazily.
   */
  protected JRealClassType findByInternalName(String internalName) {
    assert Name.isInternalName(internalName);
    return typesByInternalName.get(internalName);
  }

  private Annotation createAnnotation(TreeLogger logger,
      Class<? extends Annotation> annotationClass, AnnotationData annotationData) {
    // Make a copy before we mutate the collection.
    Map<String, Object> values = Maps.newHashMap(annotationData.getValues());
    logger =
        logger.branch(TreeLogger.TRACE, "Resolving annotation for " + annotationClass.getName());
    for (Map.Entry<String, Object> entry : values.entrySet()) {
      Method method = null;
      Throwable caught = null;
      try {
        method = annotationClass.getMethod(entry.getKey());
        entry.setValue(resolveAnnotationValue(logger, method.getReturnType(), entry.getValue()));
      } catch (SecurityException e) {
        caught = e;
      } catch (NoSuchMethodException e) {
        caught = e;
      }
      if (caught != null) {
        logger.log(TreeLogger.WARN,
            "Exception resolving " + annotationClass.getCanonicalName() + "." + entry.getKey() +
            " : " + caught.getMessage());
        return null;
      }
    }
    return AnnotationProxyFactory.create(annotationClass, values);
  }

  /**
   * Doesn't retain a reference to the TypeData.
   */
  private JRealClassType createType(
      TypeData typeData, CollectClassData collectClassData, CollectClassData enclosingClassData) {
    int access = collectClassData.getAccess();
    String simpleName = Shared.getShortName(typeData.sourceName);
    JRealClassType type = null;
    String packageName = typeData.packageName;
    JPackage pkg = typeOracle.getOrCreatePackage(packageName);
    boolean isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
    assert !collectClassData.hasNoExternalName();
    String enclosingSimpleName = null;
    if (enclosingClassData != null) {
      enclosingSimpleName = enclosingClassData.getNestedSourceName();
    }
    if ((access & Opcodes.ACC_ANNOTATION) != 0) {
      type = newAnnotationType(pkg, enclosingSimpleName, simpleName);
    } else if ((access & Opcodes.ACC_ENUM) != 0) {
      type = newEnumType(pkg, enclosingSimpleName, simpleName);
    } else {
      JTypeParameter[] typeParams = getTypeParametersForClass(collectClassData);
      if ((typeParams != null && typeParams.length > 0)
          || nonStaticInsideGeneric(collectClassData, enclosingClassData)) {
        type = new JGenericType(
            typeOracle, pkg, enclosingSimpleName, simpleName, isInterface, typeParams);
      } else {
        type = newRealClassType(pkg, enclosingSimpleName, simpleName, isInterface);
      }
    }

    type.addModifierBits(mapBits(ASM_TO_SHARED_MODIFIERS, access));
    if (isInterface) {
      // Always add implicit modifiers on interfaces.
      type.addModifierBits(Shared.MOD_STATIC | Shared.MOD_ABSTRACT);
    }
    type.addLastModifiedTime(typeData.lastModifiedTime);

    return type;
  }

  /**
   * Doesn't retain a reference to the TypeData.
   */
  private JRealClassType createType(
      TypeData typeData, Set<JRealClassType> unresolvedTypes, TypeOracleBuildContext context) {
    CollectClassData classData = context.classDataByInternalName.get(typeData.internalName);
    String enclosingClassInternalName = classData.getEnclosingInternalName();
    CollectClassData enclosingClassData = null;
    if (enclosingClassInternalName != null) {
      enclosingClassData = context.classDataByInternalName.get(enclosingClassInternalName);
      if (enclosingClassData == null) {
        // if our enclosing class was skipped, skip this one too
        return null;
      }
    }
    JRealClassType realClassType = createType(typeData, classData, enclosingClassData);
    unresolvedTypes.add(realClassType);
    return realClassType;
  }

  private Class<? extends Annotation> getAnnotationClass(
      TreeLogger logger, AnnotationData annotationData) {
    Type type = Type.getType(annotationData.getDesc());
    String binaryName = type.getClassName();
    try {
      Class<?> clazz =
          Class.forName(binaryName, false, Thread.currentThread().getContextClassLoader());
      if (!Annotation.class.isAssignableFrom(clazz)) {
        logger.log(TreeLogger.ERROR, "Type " + binaryName + " is not an annotation");
        return null;
      }
      return clazz.asSubclass(Annotation.class);
    } catch (ClassNotFoundException e) {
      TreeLogger.Type level = TreeLogger.WARN;
      if (shouldSuppressUnresolvableAnnotation(logger, binaryName)) {
        level = TreeLogger.DEBUG;
      }
      logger.log(level, "Ignoring unresolvable annotation type " + binaryName);
      return null;
    }
  }

  @SuppressWarnings("unused")
  private Class<?> getClassLiteralForPrimitive(Type type) {
    switch (type.getSort()) {
      case Type.BOOLEAN:
        return Boolean.TYPE;
      case Type.BYTE:
        return Byte.TYPE;
      case Type.CHAR:
        return Character.TYPE;
      case Type.SHORT:
        return Short.TYPE;
      case Type.INT:
        return Integer.TYPE;
      case Type.LONG:
        return Long.TYPE;
      case Type.FLOAT:
        return Float.TYPE;
      case Type.DOUBLE:
        return Double.TYPE;
      case Type.VOID:
        return Void.TYPE;
      default:
        assert false : "Unexpected primitive type " + type;
        return null;
    }
  }

  /**
   * Returns a new build context to use for the duration of one addNewTypesDontIndex() invocation.
   */
  protected TypeOracleBuildContext getContext(MethodArgNamesLookup argsLookup) {
    return new TypeOracleBuildContext(argsLookup);
  }

  /**
   * Map a bitset onto a different bitset.
   *
   * @param mapping int array containing a sequence of from/to pairs, each from entry should have
   *          exactly one bit set
   * @param input bitset to map
   * @return mapped bitset
   */
  private int mapBits(int[] mapping, int input) {
    int output = 0;
    for (int i = 0; i < mapping.length; i += 2) {
      if ((input & mapping[i]) != 0) {
        output |= mapping[i + 1];
      }
    }
    return output;
  }

  private boolean resolveAnnotation(TreeLogger logger, CollectAnnotationData annotationVisitor,
      Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
    AnnotationData annotationData = annotationVisitor.getAnnotation();
    Class<? extends Annotation> annotationClass = getAnnotationClass(logger, annotationData);
    if (annotationClass == null) {
      return false;
    }
    Annotation annotation = createAnnotation(logger, annotationClass, annotationData);
    if (annotation == null) {
      return false;
    }
    declaredAnnotations.put(annotationClass, annotation);
    return true;
  }

  private boolean resolveAnnotations(TreeLogger logger,
      List<CollectAnnotationData> annotationVisitors,
      Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
    boolean succeeded = true;
    if (annotationVisitors != null) {
      for (CollectAnnotationData annotationVisitor : annotationVisitors) {
        succeeded &= resolveAnnotation(logger, annotationVisitor, declaredAnnotations);
      }
    }
    return succeeded;
  }

  @SuppressWarnings("unchecked")
  private Object resolveAnnotationValue(TreeLogger logger, Class<?> expectedType, Object value) {
    if (expectedType.isArray()) {
      Class<?> componentType = expectedType.getComponentType();
      if (!value.getClass().isArray()) {
        logger.log(TreeLogger.WARN, "Annotation error: expected array of "
            + componentType.getCanonicalName() + ", got " + value.getClass().getCanonicalName());
        return null;
      }
      if (componentType.isPrimitive()) {
        // primitive arrays are already resolvedTypes
        return value;
      }
      // resolve each element in the array
      int n = Array.getLength(value);
      Object newArray = Array.newInstance(componentType, n);
      for (int i = 0; i < n; ++i) {
        Object valueElement = Array.get(value, i);
        Object resolvedValue = resolveAnnotationValue(logger, componentType, valueElement);
        if (resolvedValue == null || !componentType.isAssignableFrom(resolvedValue.getClass())) {
          logger.log(TreeLogger.ERROR,
              "Annotation error: expected " + componentType + ", got " + resolvedValue);
        } else {
          Array.set(newArray, i, resolvedValue);
        }
      }
      return newArray;
    } else if (expectedType.isEnum()) {
      if (!(value instanceof AnnotationEnum)) {
        logger.log(
            TreeLogger.ERROR, "Annotation error: expected an enum value," + " but got " + value);
        return null;
      }
      AnnotationEnum annotEnum = (AnnotationEnum) value;
      Class<? extends Enum> enumType = expectedType.asSubclass(Enum.class);
      try {
        return Enum.valueOf(enumType, annotEnum.getValue());
      } catch (IllegalArgumentException e) {
        logger.log(TreeLogger.WARN, "Unable to resolve annotation value '" + annotEnum.getValue()
            + "' within enum type '" + enumType.getName() + "'");
        return null;
      }
    } else if (Annotation.class.isAssignableFrom(expectedType)) {
      if (!(value instanceof AnnotationData)) {
        logger.log(TreeLogger.WARN, "Annotation error: expected annotation type "
            + expectedType.getCanonicalName() + ", got " + value.getClass().getCanonicalName());
        return null;
      }
      AnnotationData annotData = (AnnotationData) value;
      Class<? extends Annotation> annotationClass = getAnnotationClass(logger, annotData);
      if (!expectedType.isAssignableFrom(annotationClass)) {
        logger.log(TreeLogger.WARN, "Annotation error: expected " + expectedType.getCanonicalName()
            + ", got " + annotationClass.getCanonicalName());
        return null;
      }
      return createAnnotation(logger, annotationClass, annotData);
    } else if (expectedType.isPrimitive()) {
      Class<?> wrapper = getWrapperClass(expectedType);
      return wrapper.cast(value);
    } else {
      if (expectedType.isAssignableFrom(value.getClass())) {
        return value;
      }
      if (Class.class.equals(expectedType)) {
        if (!(value instanceof Type)) {
          logger.log(TreeLogger.WARN,
              "Annotation error: expected a class " + "literal, but received " + value);
          return null;
        }
        Type valueType = (Type) value;
        // See if we can use a binary only class here
        try {
          return forName(valueType.getClassName());
        } catch (ClassNotFoundException e) {
          logger.log(
              TreeLogger.WARN, "Annotation error: cannot resolve " + valueType.getClassName());
          return null;
        }
      }
      // TODO(jat) asserts about other acceptable types
      return value;
    }
  }

  private static final Map<String, Class<?>> BUILT_IN_PRIMITIVE_MAP;

  static {
    ImmutableMap.Builder<String, Class<?>> builder = ImmutableMap.<String, Class<?>>builder()
        .put("Z",  boolean.class)
        .put("B", byte.class)
        .put("C", char.class)
        .put("S", short.class)
        .put("I", int.class)
        .put("F", float.class)
        .put("D", double.class)
        .put("J", long.class)
        .put("V", void.class);

    for (Class c : new Class[] { void.class, boolean.class, byte.class, char.class,
        short.class, int.class, float.class, double.class, long.class }) {
      builder.put(c.getName(), c);
    }
    BUILT_IN_PRIMITIVE_MAP = builder.build();
  }

  public static Class forName(String name) throws ClassNotFoundException {
    Class c = BUILT_IN_PRIMITIVE_MAP.get(name);
    if (c == null) {
      c = Class.forName(name, false, Thread.currentThread().getContextClassLoader());
    }
    return c;
  }

  private JType resolveArray(Type type) {
    assert type.getSort() == Type.ARRAY;
    JType resolvedType = resolveType(type.getElementType());
    int dimensions = type.getDimensions();
    for (int i = 0; i < dimensions; ++i) {
      resolvedType = typeOracle.getArrayType(resolvedType);
    }
    return resolvedType;
  }

  // TODO(stalcup): refactor this recursive resolveFoo() process. At the moment there is a recursive
  // tree of resolveFoo() calls. Most of them return a boolean, but some do not. Some of the
  // booleans are read and acted upon, some are not. Some functions do their own logging and some
  // return a false to indicate that the caller should log. Sometimes the boolean return value is an
  // indication of whether logging should occur and other times it's an indication of whether
  // exploration should continue. It's a mess. Some ideas that would probably make this more sane:
  // be consistent about SPAM logging throughout and WARN logging only at the tip, and process types
  // in a queue instead of with recursion.
  private boolean resolveClass(
      TreeLogger logger, JRealClassType unresolvedType, TypeOracleBuildContext context) {
    assert unresolvedType != null;
    // Avoid cycles and useless computation.
    if (resolvedTypeSourceNames.contains(unresolvedType.getQualifiedSourceName())) {
      return true;
    }
    resolvedTypeSourceNames.add(unresolvedType.getQualifiedSourceName());

    // Make sure our enclosing type is resolved first.
    if (unresolvedType.getEnclosingType() != null
        && !resolveClass(logger, unresolvedType.getEnclosingType(), context)) {
      return false;
    }

    // Build a search list for type parameters to find their definition,
    // resolving enclosing classes as we go up.
    TypeParameterLookup typeParamLookup = new TypeParameterLookup();
    typeParamLookup.pushEnclosingScopes(unresolvedType);

    CollectClassData classData = context.classDataByType.get(unresolvedType);
    assert classData != null;
    int access = classData.getAccess();

    assert (!classData.getClassType().hasNoExternalName());

    logger = logger.branch(
        TreeLogger.SPAM, "Found type '" + unresolvedType.getQualifiedSourceName() + "'", null);

    // Handle package-info classes.
    if (isPackageInfoTypeName(unresolvedType.getSimpleSourceName())) {
      return resolvePackage(logger, unresolvedType, classData.getAnnotations());
    }

    // Resolve annotations
    Map<Class<? extends Annotation>, Annotation> declaredAnnotations = Maps.newHashMap();
    resolveAnnotations(logger, classData.getAnnotations(), declaredAnnotations);
    addAnnotations(unresolvedType, declaredAnnotations);

    String signature = classData.getSignature();

    /*
     * Note: Byte code from the OpenJDK compiler doesn't contain a type signature for non-static
     * inner classes of parameterized types that do not contain new parameters (but JDT compiled
     * byte code does). That can cause some differences in the way generic types are represented in
     * the type oracle.
     *
     * These differences also show up when using java.lang.reflect to look at types.
     */
    boolean isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
    if (signature != null) {
      // If we have a signature, use it for superclass and interfaces
      SignatureReader reader = new SignatureReader(signature);
      ResolveClassSignature classResolver = new ResolveClassSignature(
          context.resolver, logger, unresolvedType, typeParamLookup);
      reader.accept(classResolver);
      classResolver.finish();

      if (unresolvedType.getSuperclass() != null
          && !resolveClass(logger, unresolvedType.getSuperclass(), context)) {
        logger.log(TreeLogger.WARN,
            "Unable to resolve supertype " + unresolvedType.getSuperclass().getName());
        return false;
      }
    } else {
      // Set the super type for non-interfaces
      if (!isInterface) {
        String superInternalName = classData.getSuperInternalName();
        assert Name.isInternalName(superInternalName);
        if (superInternalName != null) {
          JClassType superType = findByInternalName(superInternalName);
          if (superType == null || !resolveClass(logger, superType, context)) {
            logger.log(TreeLogger.WARN, "Unable to resolve supertype " + superInternalName);
            return false;
          }
          setSuperClass(unresolvedType, (JClassType) possiblySubstituteRawType(superType));
        }
      }

      // Set interfaces
      for (String interfaceInternalName : classData.getInterfaceInternalNames()) {
        JClassType interfaceType = findByInternalName(interfaceInternalName);
        if (interfaceType == null || !resolveClass(logger, interfaceType, context)) {
          logger.log(TreeLogger.WARN, "Unable to resolve interface " + interfaceInternalName);
          return false;
        }
        addImplementedInterface(
            unresolvedType, (JClassType) possiblySubstituteRawType(interfaceType));
      }
    }
    if (!isInterface && unresolvedType.getSuperclass() == null) {
      // Only Object or interfaces should not have a superclass
      assert "java/lang/Object".equals(classData.getInternalName());
    }

    // Process methods
    for (CollectMethodData method : classData.getMethods()) {
      TreeLogger branch = logger.branch(TreeLogger.SPAM, "Resolving method " + method.getName());
      // TODO(rluble): Allow the users to ask for Java 8 features. For now these are filtered out.
      if (isInterface && isJava8InterfaceMethod(method)) {
        logger.log(TreeLogger.Type.SPAM, "Ignoring Java 8 interface method " + method.getName());
        continue;
      }
      if (!resolveMethod(branch, unresolvedType, method, typeParamLookup, context)) {
        // Already logged.
        return false;
      }
    }

    // Process fields
    // Track the next enum ordinal across resolveField calls.
    int[] nextEnumOrdinal = new int[] {0};
    for (CollectFieldData field : classData.getFields()) {
      TreeLogger branch = logger.branch(TreeLogger.SPAM, "Resolving field " + field.getName());
      if (!resolveField(branch, unresolvedType, field, typeParamLookup, nextEnumOrdinal, context)) {
        // Already logged.
        return false;
      }
    }
    return true;
  }

  private boolean isJava8InterfaceMethod(CollectMethodData method) {
    // (Normal) interface methods are abstract. Java 8 introduced the ability to declare default
    // methods and static methods both of which are exposed as non abstract methods.
    return (method.getAccess() & Opcodes.ACC_ABSTRACT) == 0;
  }

  private boolean resolveClass(
      TreeLogger logger, JType unresolvedType, TypeOracleBuildContext context) {
    if (!(unresolvedType instanceof JClassType)) {
      // non-classes are already resolvedTypes
      return true;
    }
    if (unresolvedType instanceof JRealClassType) {
      return resolveClass(logger, (JRealClassType) unresolvedType, context);
    }
    if (unresolvedType instanceof JArrayType) {
      return resolveClass(logger, ((JArrayType) unresolvedType).getComponentType(), context);
    }
    if (unresolvedType instanceof JParameterizedType) {
      return resolveClass(logger, ((JParameterizedType) unresolvedType).getBaseType(), context);
    }
    if (unresolvedType instanceof JRawType) {
      return resolveClass(logger, ((JRawType) unresolvedType).getBaseType(), context);
    }
    if (unresolvedType instanceof JTypeParameter) {
      JTypeParameter typeParam = (JTypeParameter) unresolvedType;
      if (!resolveClass(logger, typeParam.getDeclaringClass(), context)) {
        return false;
      }
      for (JClassType bound : typeParam.getBounds()) {
        if (!resolveClass(logger, bound, context)) {
          return false;
        }
      }
      return true;
    }
    if (unresolvedType instanceof JWildcardType) {
      JWildcardType wildcard = (JWildcardType) unresolvedType;
      for (JClassType bound : wildcard.getUpperBounds()) {
        if (!resolveClass(logger, bound, context)) {
          return false;
        }
      }
      for (JClassType bound : wildcard.getLowerBounds()) {
        if (!resolveClass(logger, bound, context)) {
          return false;
        }
      }
      return true;
    }
    return false;
  }

  private boolean resolveEnclosingClass(
      TreeLogger logger, JRealClassType unresolvedType, TypeOracleBuildContext context) {
    assert unresolvedType != null;
    if (unresolvedType.getEnclosingType() != null) {
      return true;
    }

    // Find our enclosing class and set it
    CollectClassData classData = context.classDataByType.get(unresolvedType);
    assert classData != null;
    String enclosingClassInternalName = classData.getEnclosingInternalName();
    JRealClassType enclosingType = null;
    if (enclosingClassInternalName != null) {
      enclosingType = findByInternalName(enclosingClassInternalName);
      // Ensure enclosing classes are resolved
      if (enclosingType != null) {
        if (!resolveEnclosingClass(logger, enclosingType, context)) {
          return false;
        }
        if (enclosingType.isGenericType() != null
            && (classData.getAccess() & (Opcodes.ACC_STATIC | Opcodes.ACC_INTERFACE)) != 0) {
          // If the inner class doesn't have access to it's enclosing type's
          // type variables, the enclosing type must be the raw type instead
          // of the generic type.
          JGenericType genericType = enclosingType.isGenericType();
          setEnclosingType(unresolvedType, genericType.getRawType());
        } else {
          setEnclosingType(unresolvedType, enclosingType);
        }
      }
    }
    return true;
  }

  private boolean resolveField(TreeLogger logger, JRealClassType unresolvedType,
      CollectFieldData field, TypeParameterLookup typeParamLookup, int[] nextEnumOrdinal,
      TypeOracleBuildContext context) {
    Map<Class<? extends Annotation>, Annotation> declaredAnnotations = Maps.newHashMap();
    resolveAnnotations(logger, field.getAnnotations(), declaredAnnotations);
    String name = field.getName();
    JField jfield;
    if ((field.getAccess() & Opcodes.ACC_ENUM) != 0) {
      assert (unresolvedType.isEnum() != null);
      jfield = newEnumConstant(unresolvedType, name, declaredAnnotations, nextEnumOrdinal[0]++);
    } else {
      JField newField = newField(unresolvedType, name, declaredAnnotations);
      jfield = newField;
    }

    // Get modifiers.
    addModifierBits(jfield, mapBits(ASM_TO_SHARED_MODIFIERS, field.getAccess()));

    String signature = field.getSignature();
    JType fieldJType;
    if (signature != null) {
      SignatureReader reader = new SignatureReader(signature);
      JType[] fieldTypeRef = new JType[1];
      reader.acceptType(new ResolveTypeSignature(
          context.resolver, logger, fieldTypeRef, typeParamLookup, null));
      fieldJType = fieldTypeRef[0];
      if (fieldJType == null) {
        logger.log(TreeLogger.ERROR, "Unable to resolve type in field signature " + signature);
        return false;
      }
    } else {
      Type fieldType = Type.getType(field.getDesc());
      fieldJType = resolveType(fieldType);
      if (fieldJType == null) {
        logger.log(TreeLogger.ERROR, "Unable to resolve type " + fieldType.getInternalName()
            + " of field " + field.getName());
        return false;
      }
    }
    setFieldType(jfield, fieldJType);
    return true;
  }

  private boolean resolveMethod(TreeLogger logger, JRealClassType unresolvedType,
      CollectMethodData methodData, TypeParameterLookup typeParamLookup,
      TypeOracleBuildContext context) {
    Map<Class<? extends Annotation>, Annotation> declaredAnnotations = Maps.newHashMap();
    resolveAnnotations(logger, methodData.getAnnotations(), declaredAnnotations);
    String name = methodData.getName();

    if ("<clinit>".equals(name) || (methodData.getAccess() & Opcodes.ACC_SYNTHETIC) != 0) {
      // Ignore the following and leave them out of TypeOracle:
      // - static initializers
      // - synthetic methods
      return true;
    }

    if (unresolvedType.isEnum() != null && "<init>".equals(name)) {
      // Leave enum constructors out of TypeOracle
      return true;
    }

    JAbstractMethod method;

    // Declare the type parameters. We will pass them into the constructors for
    // JConstructor/JMethod/JAnnotatedMethod. Then, we'll do a second pass to
    // resolve the bounds on each JTypeParameter object.
    JTypeParameter[] typeParams = collectTypeParams(methodData.getSignature());

    typeParamLookup.pushScope(typeParams);
    boolean hasReturnType = true;
    if ("<init>".equals(name)) {
      name = unresolvedType.getSimpleSourceName();
      method = newConstructor(unresolvedType, name, declaredAnnotations, typeParams);
      hasReturnType = false;
    } else {
      if (unresolvedType.isAnnotation() != null) {
        // TODO(jat): actually resolve the default annotation value.
        method = newAnnotationMethod(unresolvedType, name, declaredAnnotations, typeParams, null);
      } else {
        method = newMethod(unresolvedType, name, declaredAnnotations, typeParams);
      }
    }

    addModifierBits(method, mapBits(ASM_TO_SHARED_MODIFIERS, methodData.getAccess()));
    if (unresolvedType.isInterface() != null) {
      // Always add implicit modifiers on interface methods.
      addModifierBits(method, Shared.MOD_PUBLIC | Shared.MOD_ABSTRACT);
    }

    if ((methodData.getAccess() & Opcodes.ACC_VARARGS) != 0) {
      setVarArgs(method);
    }

    String signature = methodData.getSignature();
    if (signature != null) {
      // If we have a signature, use it for superclass and interfaces
      SignatureReader reader = new SignatureReader(signature);
      ResolveMethodSignature methodResolver = new ResolveMethodSignature(context.resolver, logger,
          method, typeParamLookup, hasReturnType, methodData, methodData.getArgTypes(),
          methodData.getArgNames(), methodData.hasActualArgNames(), context.allMethodArgs);
      reader.accept(methodResolver);
      if (!methodResolver.finish()) {
        logger.log(TreeLogger.ERROR, "Failed to resolve.");
        return false;
      }
    } else {
      if (hasReturnType) {
        Type returnType = Type.getReturnType(methodData.getDesc());
        JType returnJType = resolveType(returnType);
        if (returnJType == null) {
          logger.log(TreeLogger.ERROR,
              "Unable to resolve return type " + returnType.getInternalName());
          return false;
        }
        setReturnType(method, returnJType);
      }

      if (!resolveParameters(logger, method, methodData, context)) {
        // Already logged.
        return false;
      }
    }
    // The signature might not actually include the exceptions if they don't
    // include a type variable, so resolveThrows is always used (it does
    // nothing if there are already exceptions defined)
    if (!resolveThrows(logger, method, methodData)) {
      // Already logged.
      return false;
    }
    typeParamLookup.popScope();
    return true;
  }

  private JRealClassType resolveObject(Type type) {
    assert type.getSort() == Type.OBJECT;
    String internalName = type.getInternalName();
    assert Name.isInternalName(internalName);
    JRealClassType classType = findByInternalName(internalName);
    return classType;
  }

  private boolean resolvePackage(TreeLogger logger, JRealClassType unresolvedType,
      List<CollectAnnotationData> annotationVisitors) {
    Map<Class<? extends Annotation>, Annotation> declaredAnnotations = Maps.newHashMap();
    resolveAnnotations(logger, annotationVisitors, declaredAnnotations);
    addAnnotations(unresolvedType.getPackage(), declaredAnnotations);
    return true;
  }

  private boolean resolveParameters(TreeLogger logger, JAbstractMethod method,
      CollectMethodData methodData, TypeOracleBuildContext context) {
    Type[] argTypes = methodData.getArgTypes();
    boolean argNamesAreReal = methodData.hasActualArgNames();
    String[] argNames = methodData.getArgNames();
    if (!argNamesAreReal) {
      String[] lookupNames = context.allMethodArgs.lookup(method, methodData);
      if (lookupNames != null) {
        argNames = lookupNames;
        argNamesAreReal = true;
      }
    }
    List<CollectAnnotationData>[] paramAnnot = methodData.getArgAnnotations();
    for (int i = 0; i < argTypes.length; ++i) {
      Type argType = argTypes[i];
      JType argJType = resolveType(argType);
      if (argJType == null) {
        logger.log(TreeLogger.ERROR, "Unable to resolve type " + argType.getInternalName()
            + " of argument " + methodData.getArgNames()[i]);
        return false;
      }
      // Try to resolve annotations, ignore any that fail.
      Map<Class<? extends Annotation>, Annotation> declaredAnnotations = Maps.newHashMap();
      resolveAnnotations(logger, paramAnnot[i], declaredAnnotations);

      newParameter(method, argJType, argNames[i], declaredAnnotations, argNamesAreReal);
    }
    return true;
  }

  private boolean resolveThrows(TreeLogger logger, JAbstractMethod method,
      CollectMethodData methodData) {
    if (method.getThrows().length == 0) {
      for (String exceptionName : methodData.getExceptions()) {
        Type exceptionType = Type.getObjectType(exceptionName);
        JType exceptionJType = resolveType(exceptionType);
        if (exceptionJType == null) {
          logger.log(TreeLogger.ERROR,
              "Unable to resolve type " + exceptionType.getInternalName() + " of thrown exception");
          return false;
        }
        addThrows(method, (JClassType) exceptionJType);
      }
    }
    return true;
  }

  /**
   * Returns a primitive, an array, or a JRealClassType.
   */
  private JType resolveType(Type type) {
    // Check for primitives.
    switch (type.getSort()) {
      case Type.BOOLEAN:
        return JPrimitiveType.BOOLEAN;
      case Type.BYTE:
        return JPrimitiveType.BYTE;
      case Type.CHAR:
        return JPrimitiveType.CHAR;
      case Type.SHORT:
        return JPrimitiveType.SHORT;
      case Type.INT:
        return JPrimitiveType.INT;
      case Type.LONG:
        return JPrimitiveType.LONG;
      case Type.FLOAT:
        return JPrimitiveType.FLOAT;
      case Type.DOUBLE:
        return JPrimitiveType.DOUBLE;
      case Type.VOID:
        return JPrimitiveType.VOID;
      case Type.ARRAY:
        return resolveArray(type);
      case Type.OBJECT:
        JRealClassType resolvedType = resolveObject(type);
        return possiblySubstituteRawType(resolvedType);
      default:
        assert false : "Unexpected type " + type;
        return null;
    }
  }

  /**
   * Suppress multiple validation related messages and replace with a hint.
   */
  // TODO(zundel): Can be removed when javax.validation is included in the JRE
  private boolean shouldSuppressUnresolvableAnnotation(TreeLogger logger, String sourceName) {
    if (sourceName.startsWith("javax.validation.")
        || sourceName.startsWith("com.google.gwt.validation.")) {
      if (!warnedMissingValidationJar) {
        warnedMissingValidationJar = true;
        logger.log(TreeLogger.WARN, "Detected warnings related to '" + sourceName + "'. "
            + "  Is validation-<version>.jar on the classpath?");
        logger.log(TreeLogger.INFO, "Specify -logLevel DEBUG to see all errors.");
        // Show the first error that matches
        return false;
      }
      // Suppress subsequent errors that match
      return true;
    }
    return false;
  }
}