package org.checkerframework.framework.util.typeinference;

import com.sun.source.tree.AssignmentTree;
import com.sun.source.tree.CompoundAssignmentTree;
import com.sun.source.tree.ConditionalExpressionTree;
import com.sun.source.tree.ExpressionTree;
import com.sun.source.tree.LambdaExpressionTree;
import com.sun.source.tree.MemberSelectTree;
import com.sun.source.tree.MethodInvocationTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.NewArrayTree;
import com.sun.source.tree.NewClassTree;
import com.sun.source.tree.ReturnTree;
import com.sun.source.tree.Tree;
import com.sun.source.tree.Tree.Kind;
import com.sun.source.tree.VariableTree;
import com.sun.source.util.TreePath;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ErrorType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.NoType;
import javax.lang.model.type.NullType;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;
import javax.lang.model.type.TypeVisitor;
import javax.lang.model.type.UnionType;
import javax.lang.model.util.Types;
import org.checkerframework.checker.interning.qual.FindDistinct;
import org.checkerframework.framework.type.AnnotatedTypeFactory;
import org.checkerframework.framework.type.AnnotatedTypeMirror;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedArrayType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedPrimitiveType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedTypeVariable;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedWildcardType;
import org.checkerframework.framework.type.GenericAnnotatedTypeFactory;
import org.checkerframework.framework.type.QualifierHierarchy;
import org.checkerframework.framework.type.TypeVariableSubstitutor;
import org.checkerframework.framework.type.visitor.AnnotatedTypeScanner;
import org.checkerframework.framework.util.AnnotatedTypes;
import org.checkerframework.framework.util.AnnotationMirrorMap;
import org.checkerframework.framework.util.AnnotationMirrorSet;
import org.checkerframework.javacutil.BugInCF;
import org.checkerframework.javacutil.TreePathUtil;
import org.checkerframework.javacutil.TreeUtils;
import org.checkerframework.javacutil.TypeAnnotationUtils;
import org.checkerframework.javacutil.TypesUtils;
import org.plumelib.util.CollectionsPlume;

/** Miscellaneous utilities to help in type argument inference. */
public class TypeArgInferenceUtil {

  /**
   * Returns a list of boxed annotated types corresponding to the arguments in {@code
   * methodInvocation}.
   *
   * @param methodInvocation {@link MethodInvocationTree} or {@link NewClassTree}
   * @param typeFactory type factory
   * @return a list of boxed annotated types corresponding to the arguments in {@code
   *     methodInvocation}.
   */
  public static List<AnnotatedTypeMirror> getArgumentTypes(
      final ExpressionTree methodInvocation, final AnnotatedTypeFactory typeFactory) {
    final List<? extends ExpressionTree> argTrees;

    if (methodInvocation.getKind() == Kind.METHOD_INVOCATION) {
      argTrees = ((MethodInvocationTree) methodInvocation).getArguments();

    } else if (methodInvocation.getKind() == Kind.NEW_CLASS) {
      argTrees = ((NewClassTree) methodInvocation).getArguments();

    } else {
      throw new BugInCF(
          "TypeArgumentInference.relationsFromMethodArguments:%n"
              + "couldn't determine arguments from tree: %s",
          methodInvocation);
    }

    List<AnnotatedTypeMirror> argTypes =
        CollectionsPlume.mapList(
            (Tree arg) -> {
              AnnotatedTypeMirror argType = typeFactory.getAnnotatedType(arg);
              if (TypesUtils.isPrimitive(argType.getUnderlyingType())) {
                return typeFactory.getBoxedType((AnnotatedPrimitiveType) argType);
              } else {
                return argType;
              }
            },
            argTrees);
    return argTypes;
  }

  /**
   * Given a set of type variables for which we are inferring a type, returns true if type is a use
   * of a type variable in the list of targetTypeVars.
   */
  public static boolean isATarget(
      final AnnotatedTypeMirror type, final Set<TypeVariable> targetTypeVars) {
    return type.getKind() == TypeKind.TYPEVAR
        && targetTypeVars.contains(
            (TypeVariable) TypeAnnotationUtils.unannotatedType(type.getUnderlyingType()));
  }

  /**
   * Given an AnnotatedExecutableType return a set of type variables that represents the generic
   * type parameters of that method.
   */
  public static Set<TypeVariable> methodTypeToTargets(final AnnotatedExecutableType methodType) {
    final List<AnnotatedTypeVariable> annotatedTypeVars = methodType.getTypeVariables();
    final Set<TypeVariable> targets = new LinkedHashSet<>(annotatedTypeVars.size());

    for (final AnnotatedTypeVariable atv : annotatedTypeVars) {
      targets.add((TypeVariable) TypeAnnotationUtils.unannotatedType(atv.getUnderlyingType()));
    }

    return targets;
  }

  /**
   * Returns the annotated type that the leaf of path is assigned to, if it is within an assignment
   * context. Returns the annotated type that the method invocation at the leaf is assigned to. If
   * the result is a primitive, return the boxed version.
   *
   * @param atypeFactory the type factory, for looking up types
   * @param path the path whole leaf to look up a type for
   * @return the type of path's leaf
   */
  @SuppressWarnings("interning:not.interned") // AST node comparisons
  public static AnnotatedTypeMirror assignedTo(AnnotatedTypeFactory atypeFactory, TreePath path) {
    Tree assignmentContext = TreePathUtil.getAssignmentContext(path);
    AnnotatedTypeMirror res;
    if (assignmentContext == null) {
      res = null;
    } else if (assignmentContext instanceof AssignmentTree) {
      ExpressionTree variable = ((AssignmentTree) assignmentContext).getVariable();
      res = atypeFactory.getAnnotatedType(variable);
    } else if (assignmentContext instanceof CompoundAssignmentTree) {
      ExpressionTree variable = ((CompoundAssignmentTree) assignmentContext).getVariable();
      res = atypeFactory.getAnnotatedType(variable);
    } else if (assignmentContext instanceof MethodInvocationTree) {
      MethodInvocationTree methodInvocation = (MethodInvocationTree) assignmentContext;
      // TODO move to getAssignmentContext
      if (methodInvocation.getMethodSelect() instanceof MemberSelectTree
          && ((MemberSelectTree) methodInvocation.getMethodSelect()).getExpression()
              == path.getLeaf()) {
        return null;
      }
      ExecutableElement methodElt = TreeUtils.elementFromUse(methodInvocation);
      AnnotatedTypeMirror receiver = atypeFactory.getReceiverType(methodInvocation);
      res =
          assignedToExecutable(
              atypeFactory, path, methodElt, receiver, methodInvocation.getArguments());
    } else if (assignmentContext instanceof NewArrayTree) {
      // TODO: I left the previous implementation below, it definitely caused infinite loops
      // TODO: if you called it from places like the TreeAnnotator.
      res = null;

      // TODO: This may cause infinite loop
      //            AnnotatedTypeMirror type =
      //                    atypeFactory.getAnnotatedType((NewArrayTree)assignmentContext);
      //            type = AnnotatedTypes.innerMostType(type);
      //            return type;

    } else if (assignmentContext instanceof NewClassTree) {
      // This need to be basically like MethodTree
      NewClassTree newClassTree = (NewClassTree) assignmentContext;
      if (newClassTree.getEnclosingExpression() instanceof NewClassTree
          && (newClassTree.getEnclosingExpression() == path.getLeaf())) {
        return null;
      }
      ExecutableElement constructorElt = TreeUtils.constructor(newClassTree);
      AnnotatedTypeMirror receiver = atypeFactory.fromNewClass(newClassTree);
      res =
          assignedToExecutable(
              atypeFactory, path, constructorElt, receiver, newClassTree.getArguments());
    } else if (assignmentContext instanceof ReturnTree) {
      HashSet<Kind> kinds = new HashSet<>(Arrays.asList(Kind.LAMBDA_EXPRESSION, Kind.METHOD));
      Tree enclosing = TreePathUtil.enclosingOfKind(path, kinds);

      if (enclosing.getKind() == Kind.METHOD) {
        res = atypeFactory.getAnnotatedType((MethodTree) enclosing).getReturnType();
      } else {
        AnnotatedExecutableType fninf =
            atypeFactory.getFunctionTypeFromTree((LambdaExpressionTree) enclosing);
        res = fninf.getReturnType();
      }

    } else if (assignmentContext instanceof VariableTree) {
      res = assignedToVariable(atypeFactory, assignmentContext);
    } else {
      throw new BugInCF("AnnotatedTypes.assignedTo: shouldn't be here");
    }

    if (res != null && TypesUtils.isPrimitive(res.getUnderlyingType())) {
      return atypeFactory.getBoxedType((AnnotatedPrimitiveType) res);
    } else {
      return res;
    }
  }

  private static AnnotatedTypeMirror assignedToExecutable(
      AnnotatedTypeFactory atypeFactory,
      TreePath path,
      ExecutableElement methodElt,
      AnnotatedTypeMirror receiver,
      List<? extends ExpressionTree> arguments) {
    AnnotatedExecutableType method =
        AnnotatedTypes.asMemberOf(
            atypeFactory.getChecker().getTypeUtils(), atypeFactory, receiver, methodElt);
    int treeIndex = -1;
    for (int i = 0; i < arguments.size(); ++i) {
      ExpressionTree argumentTree = arguments.get(i);
      if (isArgument(path, argumentTree)) {
        treeIndex = i;
        break;
      }
    }
    final AnnotatedTypeMirror paramType;
    if (treeIndex == -1) {
      // The tree wasn't found as an argument, so it has to be the receiver.
      // This can happen for inner class constructors that take an outer class argument.
      paramType = method.getReceiverType();
    } else if (treeIndex + 1 >= method.getParameterTypes().size() && methodElt.isVarArgs()) {
      AnnotatedTypeMirror varArgsType =
          method.getParameterTypes().get(method.getParameterTypes().size() - 1);
      paramType = ((AnnotatedArrayType) varArgsType).getComponentType();
    } else {
      paramType = method.getParameterTypes().get(treeIndex);
    }

    // Examples like this:
    // <T> T outMethod()
    // <U> void inMethod(U u);
    // inMethod(outMethod())
    // would require solving the constraints for both type argument inferences simultaneously
    if (paramType == null || containsUninferredTypeParameter(paramType, method)) {
      return null;
    }

    return paramType;
  }

  /**
   * Returns whether argumentTree is the tree at the leaf of path. If tree is a conditional
   * expression, isArgument is called recursively on the true and false expressions.
   *
   * @param path the path whose leaf to test
   * @param argumentTree the expression that might be path's leaf
   * @return true if {@code argumentTree} is the leaf of {@code path}
   */
  private static boolean isArgument(TreePath path, @FindDistinct ExpressionTree argumentTree) {
    argumentTree = TreeUtils.withoutParens(argumentTree);
    if (argumentTree == path.getLeaf()) {
      return true;
    } else if (argumentTree.getKind() == Kind.CONDITIONAL_EXPRESSION) {
      ConditionalExpressionTree conditionalExpressionTree =
          (ConditionalExpressionTree) argumentTree;
      return isArgument(path, conditionalExpressionTree.getTrueExpression())
          || isArgument(path, conditionalExpressionTree.getFalseExpression());
    }
    return false;
  }

  /**
   * If the variable's type is a type variable, return getAnnotatedTypeLhsNoTypeVarDefault(tree).
   * Rational:
   *
   * <p>For example:
   *
   * <pre>{@code
   * <S> S bar () {...}
   *
   * <T> T foo(T p) {
   *     T local = bar();
   *     return local;
   *   }
   * }</pre>
   *
   * During type argument inference of {@code bar}, the assignment context is {@code local}. If the
   * local variable default is used, then the type of assignment context type is {@code @Nullable T}
   * and the type argument inferred for {@code bar()} is {@code @Nullable T}. And an incompatible
   * types in return error is issued.
   *
   * <p>If instead, the local variable default is not applied, then the assignment context type is
   * {@code T} (with lower bound {@code @NonNull Void} and upper bound {@code @Nullable Object}) and
   * the type argument inferred for {@code bar()} is {@code T}. During dataflow, the type of {@code
   * local} is refined to {@code T} and the return is legal.
   *
   * <p>If the assignment context type was a declared type, for example:
   *
   * <pre>{@code
   * <S> S bar () {...}
   * Object foo() {
   *     Object local = bar();
   *     return local;
   * }
   * }</pre>
   *
   * The local variable default must be used or else the assignment context type is missing an
   * annotation. So, an incompatible types in return error is issued in the above code. We could
   * improve type argument inference in this case and by using the lower bound of {@code S} instead
   * of the local variable default.
   *
   * @param atypeFactory AnnotatedTypeFactory
   * @param assignmentContext VariableTree
   * @return AnnotatedTypeMirror of Assignment context
   */
  public static AnnotatedTypeMirror assignedToVariable(
      AnnotatedTypeFactory atypeFactory, Tree assignmentContext) {
    if (atypeFactory instanceof GenericAnnotatedTypeFactory<?, ?, ?, ?>) {
      final GenericAnnotatedTypeFactory<?, ?, ?, ?> gatf =
          ((GenericAnnotatedTypeFactory<?, ?, ?, ?>) atypeFactory);
      return gatf.getAnnotatedTypeLhsNoTypeVarDefault(assignmentContext);
    } else {
      return atypeFactory.getAnnotatedType(assignmentContext);
    }
  }

  /**
   * Returns true if the type contains a use of a type variable from methodType.
   *
   * @return true if the type contains a use of a type variable from methodType
   */
  private static boolean containsUninferredTypeParameter(
      AnnotatedTypeMirror type, AnnotatedExecutableType methodType) {
    final List<AnnotatedTypeVariable> annotatedTypeVars = methodType.getTypeVariables();
    final List<TypeVariable> typeVars =
        CollectionsPlume.mapList(
            (AnnotatedTypeVariable annotatedTypeVar) ->
                (TypeVariable)
                    TypeAnnotationUtils.unannotatedType(annotatedTypeVar.getUnderlyingType()),
            annotatedTypeVars);

    return containsTypeParameter(type, typeVars);
  }

  /**
   * Returns true if {@code type} contains a use of a type variable in {@code typeVariables}.
   *
   * @param type type to search
   * @param typeVariables collection of type variables
   * @return true if {@code type} contains a use of a type variable in {@code typeVariables}
   */
  public static boolean containsTypeParameter(
      AnnotatedTypeMirror type, Collection<TypeVariable> typeVariables) {
    // note NULL values creep in because the underlying visitor uses them in various places
    final Boolean result = type.accept(new TypeVariableFinder(), typeVariables);
    return result != null && result;
  }

  /**
   * Take a set of annotations and separate them into a mapping of {@code hierarchy top =>
   * annotations in hierarchy}.
   */
  public static AnnotationMirrorMap<AnnotationMirror> createHierarchyMap(
      final AnnotationMirrorSet annos, final QualifierHierarchy qualifierHierarchy) {
    AnnotationMirrorMap<AnnotationMirror> result = new AnnotationMirrorMap<>();

    for (AnnotationMirror anno : annos) {
      result.put(qualifierHierarchy.getTopAnnotation(anno), anno);
    }

    return result;
  }

  /**
   * Throws an exception if the type is an uninferred type argument.
   *
   * <p>The error will be caught in DefaultTypeArgumentInference#infer and inference will be
   * aborted, but type-checking will continue.
   */
  public static void checkForUninferredTypes(AnnotatedTypeMirror type) {
    if (type.getKind() != TypeKind.WILDCARD) {
      return;
    }
    if (((AnnotatedWildcardType) type).isUninferredTypeArgument()) {
      throw new BugInCF("Can't make a constraint that includes an uninferred type argument.");
    }
  }

  /**
   * Used to detect if the visited type contains one of the type variables in the typeVars
   * parameter.
   */
  private static class TypeVariableFinder
      extends AnnotatedTypeScanner<Boolean, Collection<TypeVariable>> {

    /** Create TypeVariableFinder. */
    protected TypeVariableFinder() {
      super(Boolean::logicalOr, false);
    }

    @Override
    public Boolean visitTypeVariable(
        AnnotatedTypeVariable type, Collection<TypeVariable> typeVars) {
      if (typeVars.contains(
          (TypeVariable) TypeAnnotationUtils.unannotatedType(type.getUnderlyingType()))) {
        return true;
      } else {
        return super.visitTypeVariable(type, typeVars);
      }
    }
  }

  /*
   * Various TypeArgumentInference steps require substituting types for type arguments that have already been
   * inferred into constraints that are used infer other type arguments.  Substituter is used in
   * the utility methods to do this.
   */
  private static final TypeVariableSubstitutor substitutor = new TypeVariableSubstitutor();

  // Substituter requires an input map that the substitute methods build.  We just reuse the same
  // map rather than recreate it each time.
  private static final Map<TypeVariable, AnnotatedTypeMirror> substituteMap = new HashMap<>(5);

  /**
   * Replace all uses of typeVariable with substitution in a copy of toModify using the normal
   * substitution rules. Return the copy
   *
   * @see TypeVariableSubstitutor
   */
  public static AnnotatedTypeMirror substitute(
      final TypeVariable typeVariable,
      final AnnotatedTypeMirror substitution,
      final AnnotatedTypeMirror toModify) {
    substituteMap.clear();
    substituteMap.put(typeVariable, substitution.deepCopy());

    final AnnotatedTypeMirror toModifyCopy = toModify.deepCopy();
    substitutor.substitute(substituteMap, toModifyCopy);
    return toModifyCopy;
  }

  /**
   * Create a copy of toModify. In the copy, for each pair {@code typeVariable => annotated type}
   * replace uses of typeVariable with the corresponding annotated type using normal substitution
   * rules (@see TypeVariableSubstitutor). Return the copy.
   */
  public static AnnotatedTypeMirror substitute(
      Map<TypeVariable, AnnotatedTypeMirror> substitutions, final AnnotatedTypeMirror toModify) {
    final AnnotatedTypeMirror substitution;
    if (toModify.getKind() == TypeKind.TYPEVAR) {
      substitution =
          substitutions.get(
              (TypeVariable) TypeAnnotationUtils.unannotatedType(toModify.getUnderlyingType()));
    } else {
      substitution = null;
    }
    if (substitution != null) {
      return substitution.deepCopy();
    }

    final AnnotatedTypeMirror toModifyCopy = toModify.deepCopy();
    substitutor.substitute(substitutions, toModifyCopy);
    return toModifyCopy;
  }

  /**
   * Successively calls least upper bound on the elements of types. Unlike leastUpperBound, this
   * method will box primitives if necessary
   */
  public static AnnotatedTypeMirror leastUpperBound(
      final AnnotatedTypeFactory typeFactory, final Iterable<AnnotatedTypeMirror> types) {
    final Iterator<AnnotatedTypeMirror> typesIter = types.iterator();
    if (!typesIter.hasNext()) {
      throw new BugInCF("Calling LUB on empty list");
    }
    AnnotatedTypeMirror lubType = typesIter.next();
    AnnotatedTypeMirror nextType = null;
    while (typesIter.hasNext()) {
      nextType = typesIter.next();

      if (lubType.getKind().isPrimitive()) {
        if (!nextType.getKind().isPrimitive()) {
          lubType = typeFactory.getBoxedType((AnnotatedPrimitiveType) lubType);
        }
      } else if (nextType.getKind().isPrimitive()) {
        if (!lubType.getKind().isPrimitive()) {
          nextType = typeFactory.getBoxedType((AnnotatedPrimitiveType) nextType);
        }
      }
      lubType = AnnotatedTypes.leastUpperBound(typeFactory, lubType, nextType);
    }

    return lubType;
  }

  /**
   * If the type arguments computed by DefaultTypeArgumentInference don't match the return type
   * mirror of {@code invocation}, then replace those type arguments with an uninferred wildcard.
   */
  protected static Map<TypeVariable, AnnotatedTypeMirror> correctResults(
      Map<TypeVariable, AnnotatedTypeMirror> result,
      ExpressionTree invocation,
      ExecutableType methodType,
      AnnotatedTypeFactory factory) {
    ProcessingEnvironment env = factory.getProcessingEnv();
    Types types = env.getTypeUtils();
    Map<TypeVariable, TypeMirror> fromReturn =
        getMappingFromReturnType(invocation, methodType, env);
    for (Map.Entry<TypeVariable, AnnotatedTypeMirror> entry :
        // result is side-effected by this loop, so iterate over a copy
        new ArrayList<>(result.entrySet())) {
      TypeVariable typeVariable = entry.getKey();
      if (!fromReturn.containsKey(typeVariable)) {
        continue;
      }
      TypeMirror correctType = fromReturn.get(typeVariable);
      TypeMirror inferredType = entry.getValue().getUnderlyingType();
      if (types.isSameType(types.erasure(correctType), types.erasure(inferredType))) {
        if (areSameCapture(correctType, inferredType, types)) {
          continue;
        }
      }
      if (!types.isSameType(correctType, inferredType)) {
        AnnotatedWildcardType wt =
            factory.getUninferredWildcardType(
                (AnnotatedTypeVariable)
                    AnnotatedTypeMirror.createType(typeVariable, factory, false));
        wt.replaceAnnotations(entry.getValue().getAnnotations());
        result.put(typeVariable, wt);
      }
    }
    return result;
  }

  /**
   * Returns true if actual and inferred are captures of the same wildcard or declared type.
   *
   * @return true if actual and inferred are captures of the same wildcard or declared type
   */
  private static boolean areSameCapture(TypeMirror actual, TypeMirror inferred, Types types) {
    if (TypesUtils.isCaptured(actual) && TypesUtils.isCaptured(inferred)) {
      return true;
    } else if (TypesUtils.isCaptured(actual) && inferred.getKind() == TypeKind.WILDCARD) {
      return true;
    } else if (actual.getKind() == TypeKind.DECLARED && inferred.getKind() == TypeKind.DECLARED) {
      DeclaredType actualDT = (DeclaredType) actual;
      DeclaredType inferredDT = (DeclaredType) inferred;
      if (actualDT.getTypeArguments().size() == inferredDT.getTypeArguments().size()) {
        for (int i = 0; i < actualDT.getTypeArguments().size(); i++) {
          if (!areSameCapture(
              actualDT.getTypeArguments().get(i), inferredDT.getTypeArguments().get(i), types)) {
            return false;
          }
        }
        return true;
      }
    }
    return false;
  }

  /**
   * Returns a mapping of type variable to type argument computed using the type of {@code
   * methodInvocationTree} and the return type of {@code methodType}.
   */
  private static Map<TypeVariable, TypeMirror> getMappingFromReturnType(
      ExpressionTree methodInvocationTree, ExecutableType methodType, ProcessingEnvironment env) {
    TypeMirror methodCallType = TreeUtils.typeOf(methodInvocationTree);
    Types types = env.getTypeUtils();
    GetMapping mapping = new GetMapping(methodType.getTypeVariables(), types);
    mapping.visit(methodType.getReturnType(), methodCallType);
    return mapping.subs;
  }

  /**
   * Helper class for {@link #getMappingFromReturnType(ExpressionTree, ExecutableType,
   * ProcessingEnvironment)}
   */
  private static class GetMapping implements TypeVisitor<Void, TypeMirror> {

    final Map<TypeVariable, TypeMirror> subs = new HashMap<>();
    final List<? extends TypeVariable> typeVariables;
    final Types types;

    private GetMapping(List<? extends TypeVariable> typeVariables, Types types) {
      this.typeVariables = typeVariables;
      this.types = types;
    }

    @Override
    public Void visit(TypeMirror t, TypeMirror mirror) {
      if (t == null || mirror == null) {
        return null;
      }
      return t.accept(this, mirror);
    }

    @Override
    public Void visit(TypeMirror t) {
      return null;
    }

    @Override
    public Void visitPrimitive(PrimitiveType t, TypeMirror mirror) {
      return null;
    }

    @Override
    public Void visitNull(NullType t, TypeMirror mirror) {
      return null;
    }

    @Override
    public Void visitArray(ArrayType t, TypeMirror mirror) {
      assert mirror.getKind() == TypeKind.ARRAY : mirror;
      return visit(t.getComponentType(), ((ArrayType) mirror).getComponentType());
    }

    @Override
    public Void visitDeclared(DeclaredType t, TypeMirror mirror) {
      assert mirror.getKind() == TypeKind.DECLARED : mirror;
      DeclaredType param = (DeclaredType) mirror;
      if (types.isSubtype(mirror, param)) {
        //                param = (DeclaredType) types.asSuper((Type) mirror, ((Type)
        // param).asElement());
      }
      if (t.getTypeArguments().size() == param.getTypeArguments().size()) {
        for (int i = 0; i < t.getTypeArguments().size(); i++) {
          visit(t.getTypeArguments().get(i), param.getTypeArguments().get(i));
        }
      }
      return null;
    }

    @Override
    public Void visitError(ErrorType t, TypeMirror mirror) {
      return null;
    }

    @Override
    public Void visitTypeVariable(TypeVariable t, TypeMirror mirror) {
      if (typeVariables.contains(t)) {
        subs.put(t, mirror);
      } else if (mirror.getKind() == TypeKind.TYPEVAR) {
        TypeVariable param = (TypeVariable) mirror;
        visit(t.getUpperBound(), param.getUpperBound());
        visit(t.getLowerBound(), param.getLowerBound());
      }
      // else it's not a method type variable
      return null;
    }

    @Override
    public Void visitWildcard(javax.lang.model.type.WildcardType t, TypeMirror mirror) {
      if (mirror.getKind() == TypeKind.WILDCARD) {
        javax.lang.model.type.WildcardType param = (javax.lang.model.type.WildcardType) mirror;
        visit(t.getExtendsBound(), param.getExtendsBound());
        visit(t.getSuperBound(), param.getSuperBound());
      } else if (mirror.getKind() == TypeKind.TYPEVAR) {
        TypeVariable param = (TypeVariable) mirror;
        visit(t.getExtendsBound(), param.getUpperBound());
        visit(t.getSuperBound(), param.getLowerBound());
      } else {
        assert false : mirror;
      }
      return null;
    }

    @Override
    public Void visitExecutable(ExecutableType t, TypeMirror mirror) {
      return null;
    }

    @Override
    public Void visitNoType(NoType t, TypeMirror mirror) {
      return null;
    }

    @Override
    public Void visitUnknown(TypeMirror t, TypeMirror mirror) {
      return null;
    }

    @Override
    public Void visitUnion(UnionType t, TypeMirror mirror) {
      return null;
    }

    @Override
    public Void visitIntersection(IntersectionType t, TypeMirror mirror) {
      assert mirror.getKind() == TypeKind.INTERSECTION : mirror;
      IntersectionType param = (IntersectionType) mirror;
      assert t.getBounds().size() == param.getBounds().size();

      for (int i = 0; i < t.getBounds().size(); i++) {
        visit(t.getBounds().get(i), param.getBounds().get(i));
      }

      return null;
    }
  }
}