@Override
public Void visitType(TypeElement element, SignatureVisitor visitor) {
  if (!signatureRequired(element)) {
    return null;
  }

  for (TypeParameterElement typeParameterElement : element.getTypeParameters()) {
    typeParameterElement.accept(this, visitor);
  }

  TypeMirror superclass = element.getSuperclass();
  if (superclass.getKind() != TypeKind.NONE) {
    superclass.accept(typeVisitorAdapter, visitor.visitSuperclass());
  } else {
    // Interface type; implicit superclass of Object
    SignatureVisitor superclassVisitor = visitor.visitSuperclass();
    superclassVisitor.visitClassType("java/lang/Object");
    superclassVisitor.visitEnd();
  }

  for (TypeMirror interfaceType : element.getInterfaces()) {
    interfaceType.accept(typeVisitorAdapter, visitor.visitInterface());
  }

  return null;
}
 

@Override
public Void visitExecutable(ExecutableType t, SignatureVisitor visitor) {
  if (!signatureRequired(t)) {
    return null;
  }

  for (TypeVariable typeVariable : t.getTypeVariables()) {
    typeVariable.asElement().accept(elementVisitorAdapter, visitor);
  }

  for (TypeMirror parameter : t.getParameterTypes()) {
    parameter.accept(this, visitor.visitParameterType());
  }

  t.getReturnType().accept(this, visitor.visitReturnType());

  if (throwsATypeVar(t)) {
    for (TypeMirror thrownType : t.getThrownTypes()) {
      thrownType.accept(typeVisitorAdapter, visitor.visitExceptionType());
    }
  }

  return null;
}
 

@Override
public SignatureVisitor visitTypeArgument(final char tag) {
  if (argumentStack % 2 == 0) {
    ++argumentStack;
    declaration.append('<');
  } else {
    declaration.append(COMMA_SEPARATOR);
  }

  if (tag == EXTENDS) {
    declaration.append("? extends ");
  } else if (tag == SUPER) {
    declaration.append("? super ");
  }

  startType();
  return this;
}
 

@Override
public SignatureVisitor visitTypeArgument(final char tag) {
  if (argumentStack % 2 == 0) {
    ++argumentStack;
    declaration.append('<');
  } else {
    declaration.append(COMMA_SEPARATOR);
  }

  if (tag == EXTENDS) {
    declaration.append("? extends ");
  } else if (tag == SUPER) {
    declaration.append("? super ");
  }

  startType();
  return this;
}
 

@Override
public SignatureVisitor visitArrayType() {
  return new TypeVisitor(new Setter() {
    public void set(Type type) {
      parameters.add(type.toArray());
    }
  });
}
 

@Override
public SignatureVisitor visitExceptionType() {
  if (exceptions == null) {
    exceptions = new StringBuilder();
  } else {
    exceptions.append(COMMA_SEPARATOR);
  }
  return new TraceSignatureVisitor(exceptions);
}
 

@Override
public SignatureVisitor visitReturnType() {
  return new TypeVisitor(new Setter() {
    public void set(Type type) {
      returnType = type;
    }
  });
}
 

/**
 * Returns the given signature, remapped with the {@link SignatureVisitor} returned by {@link
 * #createSignatureRemapper(SignatureVisitor)}.
 *
 * @param signature a <i>JavaTypeSignature</i>, <i>ClassSignature</i> or <i>MethodSignature</i>.
 * @param typeSignature whether the given signature is a <i>JavaTypeSignature</i>.
 * @return signature the given signature, remapped with the {@link SignatureVisitor} returned by
 *     {@link #createSignatureRemapper(SignatureVisitor)}.
 */
public String mapSignature(final String signature, final boolean typeSignature) {
  if (signature == null) {
    return null;
  }
  SignatureReader signatureReader = new SignatureReader(signature);
  SignatureWriter signatureWriter = new SignatureWriter();
  SignatureVisitor signatureRemapper = createSignatureRemapper(signatureWriter);
  if (typeSignature) {
    signatureReader.acceptType(signatureRemapper);
  } else {
    signatureReader.accept(signatureRemapper);
  }
  return signatureWriter.toString();
}
 

@Override
public SignatureVisitor visitSuperclass() {
  endFormals();
  separator = EXTENDS_SEPARATOR;
  startType();
  return this;
}
 

@Override
public SignatureVisitor visitArrayType() {

  final TypeInfo current = this.currentType.peek();
  if (current != null) {
    current.isArray = true;
  } else {
    // on hold array flag
    this.holdArray = true;
  }
  final EntryMessage em =
      log.traceEntry("name={} current={} currentType={}", this.name, current, this.currentType);
  return log.traceExit(em, super.visitArrayType());
}
 

@Override
public SignatureVisitor visitTypeArgument(final char wildcard) {
  if (state != CLASS_TYPE) {
    throw new IllegalStateException();
  }
  if ("+-=".indexOf(wildcard) == -1) {
    throw new IllegalArgumentException();
  }
  SignatureVisitor v = sv == null ? null : sv.visitTypeArgument(wildcard);
  return new CheckSignatureAdapter(TYPE_SIGNATURE, v);
}
 

@Override
public SignatureVisitor visitClassBound() {
  if (type == TYPE_SIGNATURE || !VISIT_CLASS_BOUND_STATES.contains(state)) {
    throw new IllegalStateException();
  }
  state = State.BOUND;
  return new CheckSignatureAdapter(
      TYPE_SIGNATURE, signatureVisitor == null ? null : signatureVisitor.visitClassBound());
}
 

@Override
public SignatureVisitor visitClassBound() {
  if (type == TYPE_SIGNATURE || !VISIT_CLASS_BOUND_STATES.contains(state)) {
    throw new IllegalStateException();
  }
  state = State.BOUND;
  return new CheckSignatureAdapter(
      TYPE_SIGNATURE, signatureVisitor == null ? null : signatureVisitor.visitClassBound());
}
 

@Override
public SignatureVisitor visitInterfaceBound() {
  if (type == TYPE_SIGNATURE || !VISIT_INTERFACE_BOUND_STATES.contains(state)) {
    throw new IllegalStateException();
  }
  return new CheckSignatureAdapter(
      TYPE_SIGNATURE, signatureVisitor == null ? null : signatureVisitor.visitInterfaceBound());
}
 

/**
 * Returns the given signature, remapped with the {@link SignatureVisitor} returned by {@link
 * #createSignatureRemapper(SignatureVisitor)}.
 *
 * @param signature a <i>JavaTypeSignature</i>, <i>ClassSignature</i> or <i>MethodSignature</i>.
 * @param typeSignature whether the given signature is a <i>JavaTypeSignature</i>.
 * @return signature the given signature, remapped with the {@link SignatureVisitor} returned by
 *     {@link #createSignatureRemapper(SignatureVisitor)}.
 */
public String mapSignature(final String signature, final boolean typeSignature) {
  if (signature == null) {
    return null;
  }
  SignatureReader signatureReader = new SignatureReader(signature);
  SignatureWriter signatureWriter = new SignatureWriter();
  SignatureVisitor signatureRemapper = createSignatureRemapper(signatureWriter);
  if (typeSignature) {
    signatureReader.acceptType(signatureRemapper);
  } else {
    signatureReader.accept(signatureRemapper);
  }
  return signatureWriter.toString();
}
 

@Override
public SignatureVisitor visitTypeArgument(final char wildcard) {
  if (state != State.CLASS_TYPE) {
    throw new IllegalStateException();
  }
  if ("+-=".indexOf(wildcard) == -1) {
    throw new IllegalArgumentException();
  }
  return new CheckSignatureAdapter(
      TYPE_SIGNATURE,
      signatureVisitor == null ? null : signatureVisitor.visitTypeArgument(wildcard));
}
 

@Override
public Void visitError(ErrorType t, SignatureVisitor visitor) {
  // We don't really know, but if there's an error type the compilation is going to fail
  // anyway, so just pretend it's Object.
  visitor.visitClassType("java/lang/Object");
  visitor.visitEnd();
  return null;
}
 

@Override
public SignatureVisitor visitTypeArgument(final char wildcard) {
  if (state != State.CLASS_TYPE) {
    throw new IllegalStateException();
  }
  if ("+-=".indexOf(wildcard) == -1) {
    throw new IllegalArgumentException("Wildcard must be one of +-=");
  }
  return new CheckSignatureAdapter(
      TYPE_SIGNATURE,
      signatureVisitor == null ? null : signatureVisitor.visitTypeArgument(wildcard));
}
 

@Override
public SignatureVisitor visitSuperclass() {
  if (type != CLASS_SIGNATURE || !VISIT_SUPER_CLASS_STATES.contains(state)) {
    throw new IllegalArgumentException();
  }
  state = State.SUPER;
  return new CheckSignatureAdapter(
      TYPE_SIGNATURE, signatureVisitor == null ? null : signatureVisitor.visitSuperclass());
}
 

@Override
public SignatureVisitor visitSuperclass() {
  endFormals();
  separator = EXTENDS_SEPARATOR;
  startType();
  return this;
}
 

@Override
public SignatureVisitor visitInterface() {
  if (interfaceVisited) {
    separator = COMMA_SEPARATOR;
  } else {
    separator = isInterface ? EXTENDS_SEPARATOR : IMPLEMENTS_SEPARATOR;
    interfaceVisited = true;
  }
  startType();
  return this;
}
 

@Override
public SignatureVisitor visitParameterType() {
  endFormals();
  if (parameterTypeVisited) {
    declaration.append(COMMA_SEPARATOR);
  } else {
    declaration.append('(');
    parameterTypeVisited = true;
  }
  startType();
  return this;
}
 

@Override
public SignatureVisitor visitExceptionType() {
  if (exceptions == null) {
    exceptions = new StringBuilder();
  } else {
    exceptions.append(COMMA_SEPARATOR);
  }
  return new TraceSignatureVisitor(exceptions);
}
 

@Override
public SignatureVisitor visitSuperclass() {
  endFormals();
  separator = EXTENDS_SEPARATOR;
  startType();
  return this;
}
 

private Set<String> visitClass(String className, Map<String, byte[]> classMap) {

        DependencyCollector dependencyCollector = new DependencyCollector();

        ClassReader reader = new ClassReader(classMap.get(className));

        SignatureVisitor signatureVisitor = new SignatureDependencyVisitor(dependencyCollector);
        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
        ClassVisitor classVisitor = new ClassDependencyVisitor(signatureVisitor, dependencyCollector, writer, preserveDebugInfo);
        reader.accept(classVisitor, 0);

        classMap.put(className, writer.toByteArray());
        return dependencyCollector.getDependencies();
    }
 

@Override
public SignatureVisitor visitExceptionType() {
  if (exceptions == null) {
    exceptions = new StringBuilder();
  } else {
    exceptions.append(", ");
  }
  // startType();
  return new TraceSignatureVisitor(exceptions);
}
 

@Override
public SignatureVisitor visitInterface() {
  if (state != SUPER) {
    throw new IllegalStateException();
  }
  SignatureVisitor v = sv == null ? null : sv.visitInterface();
  return new CheckSignatureAdapter(TYPE_SIGNATURE, v);
}
 

@Override
public SignatureVisitor visitReturnType() {
  endFormals();
  if (parameterTypeVisited) {
    parameterTypeVisited = false;
  } else {
    declaration.append('(');
  }
  declaration.append(')');
  returnType = new StringBuilder();
  return new TraceSignatureVisitor(returnType);
}
 

@Override
public SignatureVisitor visitExceptionType() {
  if (type != METHOD_SIGNATURE || !VISIT_EXCEPTION_TYPE_STATES.contains(state)) {
    throw new IllegalStateException();
  }
  return new CheckSignatureAdapter(
      TYPE_SIGNATURE, signatureVisitor == null ? null : signatureVisitor.visitExceptionType());
}
 

@Override
public SignatureVisitor visitSuperclass() {
  if (type != CLASS_SIGNATURE || (state & (EMPTY | FORMAL | BOUND)) == 0) {
    throw new IllegalArgumentException();
  }
  state = SUPER;
  SignatureVisitor v = sv == null ? null : sv.visitSuperclass();
  return new CheckSignatureAdapter(TYPE_SIGNATURE, v);
}