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

-:1408af4cd8b0
+:573ceb23beeb
 /**
 * A check context is an object that can be used to perform compatibility
 * checks - depending on the check context, meaning of 'compatibility' might
 * vary significantly.
 */
-interface CheckContext {
+public interface CheckContext {
 /**
 * Is type 'found' compatible with type 'req' in given context
 */
 boolean compatible(Type found, Type req, Warner warn);
 /**
 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.
 /** Check for redundant casts (i.e. where source type is a subtype of target type)
 * The problem should only be reported for non-292 cast
 */
 public void checkRedundantCast(Env<AttrContext> env, JCTypeCast tree) {
 if (!tree.type.isErroneous() &&
 (env.info.lint == null || env.info.lint.isEnabled(Lint.LintCategory.CAST))
 && types.isSameType(tree.expr.type, tree.clazz.type)
 && !is292targetTypeCast(tree)) {
 log.warning(Lint.LintCategory.CAST,
 tree.pos(), "redundant.cast", tree.expr.type);
 }
 }
 //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

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