import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
private void checkUnsafeVarargsConversion(Type t, Type s, Warner warn) {
    if (t.tag != ARRAY || isReifiable(t)) return;
    ArrayType from = (ArrayType)t;
    boolean shouldWarn = false;
    switch (s.tag) {
        case ARRAY:
            ArrayType to = (ArrayType)s;
            shouldWarn = from.isVarargs() &&
                    !to.isVarargs() &&
                    !isReifiable(from);
            break;
        case CLASS:
            shouldWarn = from.isVarargs();
            break;
    }
    if (shouldWarn) {
        warn.warn(LintCategory.VARARGS);
    }
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Is t is castable to s?<br>
 * s is assumed to be an erased type.<br>
 * (not defined for Method and ForAll types).
 */
public boolean isCastable(Type t, Type s, Warner warn) {
    if (t == s)
        return true;

    if (t.isPrimitive() != s.isPrimitive())
        return allowBoxing && (
                isConvertible(t, s, warn)
                || (allowObjectToPrimitiveCast &&
                    s.isPrimitive() &&
                    isSubtype(boxedClass(s).type, t)));
    if (warn != warnStack.head) {
        try {
            warnStack = warnStack.prepend(warn);
            checkUnsafeVarargsConversion(t, s, warn);
            return isCastable.visit(t,s);
        } finally {
            warnStack = warnStack.tail;
        }
    } else {
        return isCastable.visit(t,s);
    }
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
@Override
public Boolean visitArrayType(ArrayType t, Type s) {
    switch (s.tag) {
    case ERROR:
    case BOT:
        return true;
    case TYPEVAR:
        if (isCastable(s, t, Warner.noWarnings)) {
            warnStack.head.warn(LintCategory.UNCHECKED);
            return true;
        } else {
            return false;
        }
    case CLASS:
        return isSubtype(t, s);
    case ARRAY:
        if (elemtype(t).tag <= lastBaseTag ||
                elemtype(s).tag <= lastBaseTag) {
            return elemtype(t).tag == elemtype(s).tag;
        } else {
            return visit(elemtype(t), elemtype(s));
        }
    default:
        return false;
    }
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
@Override
public Boolean visitTypeVar(TypeVar t, Type s) {
    switch (s.tag) {
    case ERROR:
    case BOT:
        return true;
    case TYPEVAR:
        if (isSubtype(t, s)) {
            return true;
        } else if (isCastable(t.bound, s, Warner.noWarnings)) {
            warnStack.head.warn(LintCategory.UNCHECKED);
            return true;
        } else {
            return false;
        }
    default:
        return isCastable(t.bound, s, warnStack.head);
    }
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
public boolean returnTypeSubstitutable(Type r1,
                                       Type r2, Type r2res,
                                       Warner warner) {
    if (isSameType(r1.getReturnType(), r2res))
        return true;
    if (r1.getReturnType().isPrimitive() || r2res.isPrimitive())
        return false;

    if (hasSameArgs(r1, r2))
        return covariantReturnType(r1.getReturnType(), r2res, warner);
    if (!allowCovariantReturns)
        return false;
    if (isSubtypeUnchecked(r1.getReturnType(), r2res, warner))
        return true;
    if (!isSubtype(r1.getReturnType(), erasure(r2res)))
        return false;
    warner.warn(LintCategory.UNCHECKED);
    return true;
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Instantiate inference variables in legacy mode (JLS 15.12.2.7, 15.12.2.8).
 * During overload resolution, instantiation is done by doing a partial
 * inference process using eq/lower bound instantiation. During check,
 * we also instantiate any remaining vars by repeatedly using eq/upper
 * instantiation, until all variables are solved.
 */
public void solveLegacy(boolean partial, Warner warn, EnumSet<InferenceStep> steps) {
    while (true) {
        List<Type> solvedVars = solveBasic(steps);
        if (restvars().isEmpty() || partial) {
            //all variables have been instantiated - exit
            break;
        } else if (solvedVars.isEmpty()) {
            //some variables could not be instantiated because of cycles in
            //upper bounds - provide a (possibly recursive) default instantiation
            infer.instantiateAsUninferredVars(restvars(), this);
            break;
        } else {
            //some variables have been instantiated - replace newly instantiated
            //variables in remaining upper bounds and continue
            for (Type t : undetvars) {
                UndetVar uv = (UndetVar)t;
                uv.substBounds(solvedVars, asInstTypes(solvedVars), types);
            }
        }
    }
    infer.doIncorporation(this, warn);
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
@Nullable
private Unifier match(List<JCStatement> targetStatements, Context context) {
  checkArgument(templateStatements().size() == targetStatements.size());
  Unifier unifier = new Unifier(context);
  for (int i = 0; i < templateStatements().size() && unifier != null; i++) {
    unifier = templateStatements().get(i).unify(targetStatements.get(i), unifier);
  }
  if (unifier != null) {
    Inliner inliner = unifier.createInliner();
    try {
      return typecheck(
          unifier, inliner, new Warner(targetStatements.get(0)), expectedTypes(inliner),
          actualTypes(inliner));
    } catch (CouldNotResolveImportException e) {
      logger.log(FINE, "Failure to resolve import", e);
    }
  }
  return null;
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
@Override
@Nullable
public Unifier unify(JCExpression target, Unifier unifier) {
  unifier = expression().unify(target, unifier);
  if (unifier != null) {
    Inliner inliner = unifier.createInliner();
    try {
      List<Type> expectedTypes = expectedTypes(inliner);
      List<Type> actualTypes = actualTypes(inliner);
      /*
       * The Java compiler's type inference doesn't directly take into account the expected
       * return type, so we test the return type by treating the expected return type as an
       * extra method argument, and the actual type of the return expression as its actual
       * value.
       */
      expectedTypes = expectedTypes.prepend(returnType().inline(inliner));
      actualTypes = actualTypes.prepend(target.type);

      return typecheck(unifier, inliner, new Warner(target), expectedTypes, actualTypes);
    } catch (CouldNotResolveImportException e) {
      logger.log(FINE, "Failure to resolve import", e);
    }
  }
  return null;
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Returns the inferred method type of the template based on the given actual argument types.
 *
 * @throws NoInstanceException if no instances of the specified type variables would allow the
 *         {@code actualArgTypes} to match the {@code expectedArgTypes}
 */
private Type infer(Warner warner,
    Inliner inliner,
    List<Type> freeTypeVariables,
    List<Type> expectedArgTypes,
    Type returnType,
    List<Type> actualArgTypes) throws NoInstanceException {
  Symtab symtab = inliner.symtab();
  MethodType methodType =
      new MethodType(expectedArgTypes, returnType, List.<Type>nil(), symtab.methodClass);
  Enter enter = inliner.enter();
  MethodSymbol methodSymbol =
      new MethodSymbol(0, inliner.asName("__m__"), methodType, symtab.unknownSymbol);
  return inliner.infer().instantiateMethod(enter.getEnv(methodType.tsym),
      freeTypeVariables,
      methodType,
      methodSymbol,
      actualArgTypes,
      autoboxing(),
      false,
      warner);
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
private void assertConvertible(JCTree tree, Type actual, Type formal, Warner warn) {
    if (types.isConvertible(actual, formal, warn))
        return;

    if (formal.isCompound()
        && types.isSubtype(actual, types.supertype(formal))
        && types.isSubtypeUnchecked(actual, types.interfaces(formal), warn))
        return;

    if (false) {
        // TODO: make assertConvertible work
        chk.typeError(tree.pos(), diags.fragment("incompatible.types"), actual, formal);
        throw new AssertionError("Tree: " + tree
                                 + " actual:" + actual
                                 + " formal: " + formal);
    }
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Is t a subtype of or convertible via boxing/unboxing
 * conversion to s?
 */
public boolean isConvertible(Type t, Type s, Warner warn) {
    if (t.tag == ERROR)
        return true;
    boolean tPrimitive = t.isPrimitive();
    boolean sPrimitive = s.isPrimitive();
    if (tPrimitive == sPrimitive) {
        return isSubtypeUnchecked(t, s, warn);
    }
    if (!allowBoxing) return false;
    return tPrimitive
        ? isSubtype(boxedClass(t).type, s)
        : isSubtype(unboxedType(t), s);
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Is t an unchecked subtype of s?
 */
public boolean isSubtypeUnchecked(Type t, Type s, Warner warn) {
    boolean result = isSubtypeUncheckedInternal(t, s, warn);
    if (result) {
        checkUnsafeVarargsConversion(t, s, warn);
    }
    return result;
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
private boolean isSubtypeUncheckedInternal(Type t, Type s, Warner warn) {
    if (t.tag == ARRAY && s.tag == ARRAY) {
        if (((ArrayType)t).elemtype.tag <= lastBaseTag) {
            return isSameType(elemtype(t), elemtype(s));
        } else {
            return isSubtypeUnchecked(elemtype(t), elemtype(s), warn);
        }
    } else if (isSubtype(t, s)) {
        return true;
    }
    else if (t.tag == TYPEVAR) {
        return isSubtypeUnchecked(t.getUpperBound(), s, warn);
    }
    else if (s.tag == UNDETVAR) {
        UndetVar uv = (UndetVar)s;
        if (uv.inst != null)
            return isSubtypeUnchecked(t, uv.inst, warn);
    }
    else if (!s.isRaw()) {
        Type t2 = asSuper(t, s.tsym);
        if (t2 != null && t2.isRaw()) {
            if (isReifiable(s))
                warn.silentWarn(LintCategory.UNCHECKED);
            else
                warn.warn(LintCategory.UNCHECKED);
            return true;
        }
    }
    return false;
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Are corresponding elements of ts subtypes of ss, allowing
 * unchecked conversions?  If lists are of different length,
 * return false.
 **/
public boolean isSubtypesUnchecked(List<Type> ts, List<Type> ss, Warner warn) {
    while (ts.tail != null && ss.tail != null
           /*inlined: ts.nonEmpty() && ss.nonEmpty()*/ &&
           isSubtypeUnchecked(ts.head, ss.head, warn)) {
        ts = ts.tail;
        ss = ss.tail;
    }
    return ts.tail == null && ss.tail == null;
    /*inlined: ts.isEmpty() && ss.isEmpty();*/
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * This relation answers the question: is impossible that
 * something of type `t' can be a subtype of `s'? This is
 * different from the question "is `t' not a subtype of `s'?"
 * when type variables are involved: Integer is not a subtype of T
 * where <T extends Number> but it is not true that Integer cannot
 * possibly be a subtype of T.
 */
public boolean notSoftSubtype(Type t, Type s) {
    if (t == s) return false;
    if (t.tag == TYPEVAR) {
        TypeVar tv = (TypeVar) t;
        return !isCastable(tv.bound,
                           relaxBound(s),
                           Warner.noWarnings);
    }
    if (s.tag != WILDCARD)
        s = upperBound(s);

    return !isSubtype(t, relaxBound(s));
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Is t assignable to s?<br>
 * Equivalent to subtype except for constant values and raw
 * types.<br>
 * (not defined for Method and ForAll types)
 */
public boolean isAssignable(Type t, Type s, Warner warn) {
    if (t.tag == ERROR)
        return true;
    if (t.tag <= INT && t.constValue() != null) {
        int value = ((Number)t.constValue()).intValue();
        switch (s.tag) {
        case BYTE:
            if (Byte.MIN_VALUE <= value && value <= Byte.MAX_VALUE)
                return true;
            break;
        case CHAR:
            if (Character.MIN_VALUE <= value && value <= Character.MAX_VALUE)
                return true;
            break;
        case SHORT:
            if (Short.MIN_VALUE <= value && value <= Short.MAX_VALUE)
                return true;
            break;
        case INT:
            return true;
        case CLASS:
            switch (unboxedType(s).tag) {
            case BYTE:
            case CHAR:
            case SHORT:
                return isAssignable(t, unboxedType(s), warn);
            }
            break;
        }
    }
    return isConvertible(t, s, warn);
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Is t an appropriate return type in an overrider for a
 * method that returns s?
 */
public boolean covariantReturnType(Type t, Type s, Warner warner) {
    return
        isSameType(t, s) ||
        allowCovariantReturns &&
        !t.isPrimitive() &&
        !s.isPrimitive() &&
        isAssignable(t, s, warner);
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
private boolean sideCast(Type from, Type to, Warner warn) {
    // We are casting from type $from$ to type $to$, which are
    // non-final unrelated types.  This method
    // tries to reject a cast by transferring type parameters
    // from $to$ to $from$ by common superinterfaces.
    boolean reverse = false;
    Type target = to;
    if ((to.tsym.flags() & INTERFACE) == 0) {
        Assert.check((from.tsym.flags() & INTERFACE) != 0);
        reverse = true;
        to = from;
        from = target;
    }
    List<Type> commonSupers = superClosure(to, erasure(from));
    boolean giveWarning = commonSupers.isEmpty();
    // The arguments to the supers could be unified here to
    // get a more accurate analysis
    while (commonSupers.nonEmpty()) {
        Type t1 = asSuper(from, commonSupers.head.tsym);
        Type t2 = commonSupers.head; // same as asSuper(to, commonSupers.head.tsym);
        if (disjointTypes(t1.getTypeArguments(), t2.getTypeArguments()))
            return false;
        giveWarning = giveWarning || (reverse ? giveWarning(t2, t1) : giveWarning(t1, t2));
        commonSupers = commonSupers.tail;
    }
    if (giveWarning && !isReifiable(reverse ? from : to))
        warn.warn(LintCategory.UNCHECKED);
    if (!allowCovariantReturns)
        // reject if there is a common method signature with
        // incompatible return types.
        chk.checkCompatibleAbstracts(warn.pos(), from, to);
    return true;
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
private boolean sideCastFinal(Type from, Type to, Warner warn) {
    // We are casting from type $from$ to type $to$, which are
    // unrelated types one of which is final and the other of
    // which is an interface.  This method
    // tries to reject a cast by transferring type parameters
    // from the final class to the interface.
    boolean reverse = false;
    Type target = to;
    if ((to.tsym.flags() & INTERFACE) == 0) {
        Assert.check((from.tsym.flags() & INTERFACE) != 0);
        reverse = true;
        to = from;
        from = target;
    }
    Assert.check((from.tsym.flags() & FINAL) != 0);
    Type t1 = asSuper(from, to.tsym);
    if (t1 == null) return false;
    Type t2 = to;
    if (disjointTypes(t1.getTypeArguments(), t2.getTypeArguments()))
        return false;
    if (!allowCovariantReturns)
        // reject if there is a common method signature with
        // incompatible return types.
        chk.checkCompatibleAbstracts(warn.pos(), from, to);
    if (!isReifiable(target) &&
        (reverse ? giveWarning(t2, t1) : giveWarning(t1, t2)))
        warn.warn(LintCategory.UNCHECKED);
    return true;
}
 

import com.sun.tools.javac.util.Warner; //导入依赖的package包/类
/**
 * Solve all variables in this context.
 */
public void solve(Warner warn) {
    solve(infer.new LeafSolver() {
        public boolean done() {
            return restvars().isEmpty();
        }
    }, warn);
}