jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Attr.java

-:de932285124c
+:1df20330f6bd
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.comp.Check.CheckContext;
 import com.sun.tools.javac.comp.DeferredAttr.AttrMode;
 import com.sun.tools.javac.comp.Infer.InferenceContext;
-import com.sun.tools.javac.comp.Infer.InferenceContext.FreeTypeListener;
+import com.sun.tools.javac.comp.Infer.FreeTypeListener;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.tree.JCTree.JCPolyExpression.*;
 import com.sun.tools.javac.util.*;
 if (inferenceContext.free(found)) {
 inferenceContext.addFreeTypeListener(List.of(found, resultInfo.pt), new FreeTypeListener() {
 @Override
 public void typesInferred(InferenceContext inferenceContext) {
 ResultInfo pendingResult =
-resultInfo.dup(inferenceContext.asInstType(resultInfo.pt, types));
+resultInfo.dup(inferenceContext.asInstType(resultInfo.pt));
-check(tree, inferenceContext.asInstType(found, types), ownkind, pendingResult);
+check(tree, inferenceContext.asInstType(found), ownkind, pendingResult);
 }
 });
 return tree.type = resultInfo.pt;
 } else {
 if ((ownkind & ~resultInfo.pkind) == 0) {
 private void checkAccessibleTypes(final DiagnosticPosition pos, final Env<AttrContext> env, final InferenceContext inferenceContext, final List<Type> ts) {
 if (inferenceContext.free(ts)) {
 inferenceContext.addFreeTypeListener(ts, new FreeTypeListener() {
 @Override
 public void typesInferred(InferenceContext inferenceContext) {
-checkAccessibleTypes(pos, env, inferenceContext, inferenceContext.asInstTypes(ts, types));
+checkAccessibleTypes(pos, env, inferenceContext, inferenceContext.asInstTypes(ts));
 }
 });
 } else {
 for (Type t : ts) {
 rs.checkAccessibleType(env, t);
 }
 @Override
 public boolean compatible(Type found, Type req, Warner warn) {
 //return type must be compatible in both current context and assignment context
-return chk.basicHandler.compatible(found, inferenceContext().asFree(req, types), warn);
+return chk.basicHandler.compatible(found, inferenceContext().asFree(req), warn);
 }
 @Override
 public void report(DiagnosticPosition pos, JCDiagnostic details) {
 enclosingContext.report(pos, diags.fragment("incompatible.ret.type.in.lambda", details));
 * types must be compatible with the return type of the expected descriptor;
 * (iii) thrown types must be 'included' in the thrown types list of the expected
 * descriptor.
 */
 private void checkLambdaCompatible(JCLambda tree, Type descriptor, CheckContext checkContext, boolean speculativeAttr) {
-Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType(), types);
+Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType());
 //return values have already been checked - but if lambda has no return
 //values, we must ensure that void/value compatibility is correct;
 //this amounts at checking that, if a lambda body can complete normally,
 //the descriptor's return type must be void
 !returnType.hasTag(VOID) && returnType != Type.recoveryType) {
 checkContext.report(tree, diags.fragment("incompatible.ret.type.in.lambda",
 diags.fragment("missing.ret.val", returnType)));
 }
-List<Type> argTypes = checkContext.inferenceContext().asFree(descriptor.getParameterTypes(), types);
+List<Type> argTypes = checkContext.inferenceContext().asFree(descriptor.getParameterTypes());
 if (!types.isSameTypes(argTypes, TreeInfo.types(tree.params))) {
 checkContext.report(tree, diags.fragment("incompatible.arg.types.in.lambda"));
 }
 if (!speculativeAttr) {
-List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes(), types);
+List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes());
 if (chk.unhandled(tree.inferredThrownTypes == null ? List.<Type>nil() : tree.inferredThrownTypes, thrownTypes).nonEmpty()) {
 log.error(tree, "incompatible.thrown.types.in.lambda", tree.inferredThrownTypes);
 }
 }
 }
 }
 }
 @SuppressWarnings("fallthrough")
 void checkReferenceCompatible(JCMemberReference tree, Type descriptor, Type refType, CheckContext checkContext, boolean speculativeAttr) {
-Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType(), types);
+Type returnType = checkContext.inferenceContext().asFree(descriptor.getReturnType());
 Type resType;
 switch (tree.getMode()) {
 case NEW:
 if (!tree.expr.type.isRaw()) {
 checkContext.report(tree, diags.fragment("incompatible.ret.type.in.mref",
 diags.fragment("inconvertible.types", resType, descriptor.getReturnType())));
 }
 if (!speculativeAttr) {
-List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes(), types);
+List<Type> thrownTypes = checkContext.inferenceContext().asFree(descriptor.getThrownTypes());
 if (chk.unhandled(refType.getThrownTypes(), thrownTypes).nonEmpty()) {
 log.error(tree, "incompatible.thrown.types.in.mref", refType.getThrownTypes());
 }
 }
 }
 */
 private void setFunctionalInfo(final JCFunctionalExpression fExpr, final Type pt, final Type descriptorType, InferenceContext inferenceContext) {
 if (inferenceContext.free(descriptorType)) {
 inferenceContext.addFreeTypeListener(List.of(pt, descriptorType), new FreeTypeListener() {
 public void typesInferred(InferenceContext inferenceContext) {
-setFunctionalInfo(fExpr, pt, inferenceContext.asInstType(descriptorType, types), inferenceContext);
+setFunctionalInfo(fExpr, pt, inferenceContext.asInstType(descriptorType), inferenceContext);
 }
 });
 } else {
 ListBuffer<TypeSymbol> targets = ListBuffer.lb();
 if (pt.hasTag(CLASS)) {

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Attr.java

src/share/classes/com/sun/tools/javac/comp/Attr.java