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

-:843d3b191773
+:01c9d4161882
 allowVarargs = source.allowVarargs();
 allowAnnotations = source.allowAnnotations();
 allowCovariantReturns = source.allowCovariantReturns();
 allowSimplifiedVarargs = source.allowSimplifiedVarargs();
 allowDefaultMethods = source.allowDefaultMethods();
-allowStrictMethodClashCheck = source.allowStrictMethodClashCheck() &&
+allowStrictMethodClashCheck = source.allowStrictMethodClashCheck();
-options.isSet("strictMethodClashCheck"); //pre-lambda guard
 complexInference = options.isSet("complexinference");
 warnOnSyntheticConflicts = options.isSet("warnOnSyntheticConflicts");
 suppressAbortOnBadClassFile = options.isSet("suppressAbortOnBadClassFile");
 enableSunApiLintControl = options.isSet("enableSunApiLintControl");
 public Warner checkWarner(DiagnosticPosition pos, Type found, Type req);
 public Infer.InferenceContext inferenceContext();
 public DeferredAttr.DeferredAttrContext deferredAttrContext();
-public boolean allowBoxing();
 }
 /**
 * This class represent a check context that is nested within another check
 * context - useful to check sub-expressions. The default behavior simply
 }
 public DeferredAttrContext deferredAttrContext() {
 return enclosingContext.deferredAttrContext();
 }
-public boolean allowBoxing() {
-return enclosingContext.allowBoxing();
-}
 }
 /**
 * Check context to be used when evaluating assignment/return statements
 */
 return infer.emptyContext;
 }
 public DeferredAttrContext deferredAttrContext() {
 return deferredAttr.emptyDeferredAttrContext;
-}
-public boolean allowBoxing() {
-return true;
 }
 };
 /** Check that a given type is assignable to a given proto-type.
 *  If it is, return the type, otherwise return errType.
 return true;
 } else if (!a.hasTag(WILDCARD)) {
 a = types.upperBound(a);
 return types.isSubtype(a, bound);
 } else if (a.isExtendsBound()) {
-return types.isCastable(bound, types.upperBound(a), Warner.noWarnings);
+return types.isCastable(bound, types.upperBound(a), types.noWarnings);
 } else if (a.isSuperBound()) {
 return !types.notSoftSubtype(types.lowerBound(a), bound);
 }
 return true;
 }
 !isTrustMeAllowedOnMethod(sym))) {
 warnUnchecked(env.tree.pos(),
 "unchecked.generic.array.creation",
 argtype);
 }
-Type elemtype = types.elemtype(argtype);
+if (!((MethodSymbol)sym.baseSymbol()).isSignaturePolymorphic(types)) {
-switch (tree.getTag()) {
+Type elemtype = types.elemtype(argtype);
-case APPLY:
+switch (tree.getTag()) {
-((JCMethodInvocation) tree).varargsElement = elemtype;
+case APPLY:
-break;
+((JCMethodInvocation) tree).varargsElement = elemtype;
-case NEWCLASS:
+break;
-((JCNewClass) tree).varargsElement = elemtype;
+case NEWCLASS:
-break;
+((JCNewClass) tree).varargsElement = elemtype;
-case REFERENCE:
+break;
-((JCMemberReference) tree).varargsElement = elemtype;
+case REFERENCE:
-break;
+((JCMemberReference) tree).varargsElement = elemtype;
-default:
+break;
-throw new AssertionError(""+tree);
+default:
+throw new AssertionError(""+tree);
+}
 }
 }
 return owntype;
 }
 //where
 && types.isSubtype(actual, types.supertype(formal))
 && types.isSubtypeUnchecked(actual, types.interfaces(formal), warn))
 return;
 }
-void checkAccessibleFunctionalDescriptor(DiagnosticPosition pos, Env<AttrContext> env, Type desc) {
-AccessChecker accessChecker = new AccessChecker(env);
-//check args accessibility (only if implicit parameter types)
-for (Type arg : desc.getParameterTypes()) {
-if (!accessChecker.visit(arg)) {
-log.error(pos, "cant.access.arg.type.in.functional.desc", arg);
-return;
-}
-}
-//check return type accessibility
-if (!accessChecker.visit(desc.getReturnType())) {
-log.error(pos, "cant.access.return.in.functional.desc", desc.getReturnType());
-return;
-}
-//check thrown types accessibility
-for (Type thrown : desc.getThrownTypes()) {
-if (!accessChecker.visit(thrown)) {
-log.error(pos, "cant.access.thrown.in.functional.desc", thrown);
-return;
-}
-}
-}
-class AccessChecker extends Types.UnaryVisitor<Boolean> {
-Env<AttrContext> env;
-AccessChecker(Env<AttrContext> env) {
-this.env = env;
-}
-Boolean visit(List<Type> ts) {
-for (Type t : ts) {
-if (!visit(t))
-return false;
-}
-return true;
-}
-public Boolean visitType(Type t, Void s) {
-return true;
-}
-@Override
-public Boolean visitArrayType(ArrayType t, Void s) {
-return visit(t.elemtype);
-}
-@Override
-public Boolean visitClassType(ClassType t, Void s) {
-return rs.isAccessible(env, t, true) &&
-visit(t.getTypeArguments());
-}
-@Override
-public Boolean visitWildcardType(WildcardType t, Void s) {
-return visit(t.type);
-}
-};
 /**
 * Check that type 't' is a valid instantiation of a generic class
 * (see JLS 4.5)
 *
 * @param t class type to be checked
 Type rt2 = types.subst(st2.getReturnType(), tvars2, tvars1);
 boolean compat =
 types.isSameType(rt1, rt2) ||
 !rt1.isPrimitiveOrVoid() &&
 !rt2.isPrimitiveOrVoid() &&
-(types.covariantReturnType(rt1, rt2, Warner.noWarnings) ||
+(types.covariantReturnType(rt1, rt2, types.noWarnings) ||
-types.covariantReturnType(rt2, rt1, Warner.noWarnings)) ||
+types.covariantReturnType(rt2, rt1, types.noWarnings)) ||
 checkCommonOverriderIn(s1,s2,site);
 if (!compat) {
 log.error(pos, "types.incompatible.diff.ret",
 t1, t2, s2.name +
 "(" + types.memberType(t2, s2).getParameterTypes() + ")");
 Type rt13 = types.subst(st3.getReturnType(), tvars3, tvars1);
 Type rt23 = types.subst(st3.getReturnType(), tvars3, tvars2);
 boolean compat =
 !rt13.isPrimitiveOrVoid() &&
 !rt23.isPrimitiveOrVoid() &&
-(types.covariantReturnType(rt13, rt1, Warner.noWarnings) &&
+(types.covariantReturnType(rt13, rt1, types.noWarnings) &&
-types.covariantReturnType(rt23, rt2, Warner.noWarnings));
+types.covariantReturnType(rt23, rt2, types.noWarnings));
 if (compat)
 return true;
 }
 }
 }
 ((ClassType)c.type).supertype_field = types.createErrorType((ClassSymbol)st.tsym, Type.noType);
 c.type = types.createErrorType(c, c.type);
 c.flags_field |= ACYCLIC;
 }
+/**
+* Check that functional interface methods would make sense when seen
+* from the perspective of the implementing class
+*/
+void checkFunctionalInterface(JCTree tree, Type funcInterface) {
+ClassType c = new ClassType(Type.noType, List.<Type>nil(), null);
+ClassSymbol csym = new ClassSymbol(0, names.empty, c, syms.noSymbol);
+c.interfaces_field = List.of(funcInterface);
+c.supertype_field = syms.objectType;
+c.tsym = csym;
+csym.members_field = new Scope(csym);
+csym.completer = null;
+checkImplementations(tree, csym, csym);
+}
 /** Check that all methods which implement some
 *  method conform to the method they implement.
 *  @param tree         The class definition whose members are checked.
 */
 void checkImplementations(JCClassDecl tree) {
-checkImplementations(tree, tree.sym);
+checkImplementations(tree, tree.sym, tree.sym);
 }
 //where
 /** Check that all methods which implement some
 *  method in `ic' conform to the method they implement.
 */
-void checkImplementations(JCClassDecl tree, ClassSymbol ic) {
+void checkImplementations(JCTree tree, ClassSymbol origin, ClassSymbol ic) {
-ClassSymbol origin = tree.sym;
 for (List<Type> l = types.closure(ic.type); l.nonEmpty(); l = l.tail) {
 ClassSymbol lc = (ClassSymbol)l.head.tsym;
 if ((allowGenerics || origin != lc) && (lc.flags() & ABSTRACT) != 0) {
 for (Scope.Entry e=lc.members().elems; e != null; e=e.sibling) {
 if (e.sym.kind == MTH &&

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

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

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