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

-:5c956be64b9e
+:71f35e4b93a5
 */
 package com.sun.tools.javac.comp;
 import java.util.*;
-import java.util.Set;
 import javax.tools.JavaFileManager;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.jvm.*;
 import com.sun.tools.javac.tree.*;
 protected Check(Context context) {
 context.put(checkKey, this);
 names = Names.instance(context);
+dfltTargetMeta = new Name[] { names.PACKAGE, names.TYPE,
+names.FIELD, names.METHOD, names.CONSTRUCTOR,
+names.ANNOTATION_TYPE, names.LOCAL_VARIABLE, names.PARAMETER};
 log = Log.instance(context);
 rs = Resolve.instance(context);
 syms = Symtab.instance(context);
 enter = Enter.instance(context);
 deferredAttr = DeferredAttr.instance(context);
 */
 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)
+&& !(ignoreAnnotatedCasts && TreeInfo.containsTypeAnnotation(tree.clazz))
 && !is292targetTypeCast(tree)) {
 log.warning(Lint.LintCategory.CAST,
 tree.pos(), "redundant.cast", tree.expr.type);
 }
 }
 //where
 private boolean is292targetTypeCast(JCTypeCast tree) {
 boolean is292targetTypeCast = false;
 JCExpression expr = TreeInfo.skipParens(tree.expr);
 if (expr.hasTag(APPLY)) {
 JCMethodInvocation apply = (JCMethodInvocation)expr;
 Symbol sym = TreeInfo.symbol(apply.meth);
 is292targetTypeCast = sym != null &&
 sym.kind == MTH &&
 (sym.flags() & HYPOTHETICAL) != 0;
 }
 return is292targetTypeCast;
 }
+private static final boolean ignoreAnnotatedCasts = true;
-//where
-/** Is type a type variable, or a (possibly multi-dimensional) array of
-*  type variables?
-*/
-boolean isTypeVar(Type t) {
-return t.hasTag(TYPEVAR) || t.hasTag(ARRAY) && isTypeVar(types.elemtype(t));
-}
 /** Check that a type is within some bounds.
 *
 *  Used in TypeApply to verify that, e.g., X in {@code V<X>} is a valid
 *  type argument.
 // System.out.println("call   : " + env.tree);
 // System.out.println("method : " + owntype);
 // System.out.println("actuals: " + argtypes);
 List<Type> formals = owntype.getParameterTypes();
 Type last = useVarargs ? formals.last() : null;
-if (sym.name==names.init &&
+if (sym.name == names.init &&
 sym.owner == syms.enumSym)
 formals = formals.tail.tail;
 List<JCExpression> args = argtrees;
 DeferredAttr.DeferredTypeMap checkDeferredMap =
 deferredAttr.new DeferredTypeMap(DeferredAttr.AttrMode.CHECK, sym, env.info.pendingResolutionPhase);
 log.error(tree.pos(), "cant.select.static.class.from.param.type");
 } else {
 // otherwise validate the rest of the expression
 tree.selected.accept(this);
 }
+}
+@Override
+public void visitAnnotatedType(JCAnnotatedType tree) {
+tree.underlyingType.accept(this);
 }
 /** Default visitor method: do nothing.
 */
 @Override
 *  @param tree         The class definition whose members are checked.
 */
 void checkImplementations(JCClassDecl tree) {
 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(JCTree tree, ClassSymbol origin, ClassSymbol ic) {
 for (List<Type> l = types.closure(ic.type); l.nonEmpty(); l = l.tail) {
 public void validateAnnotations(List<JCAnnotation> annotations, Symbol s) {
 for (JCAnnotation a : annotations)
 validateAnnotation(a, s);
 }
+/** Check the type annotations.
+*/
+public void validateTypeAnnotations(List<JCAnnotation> annotations, boolean isTypeParameter) {
+for (JCAnnotation a : annotations)
+validateTypeAnnotation(a, isTypeParameter);
+}
 /** Check an annotation of a symbol.
 */
 private void validateAnnotation(JCAnnotation a, Symbol s) {
 validateAnnotationTree(a);
 } catch (Types.FunctionDescriptorLookupError ex) {
 log.error(a.pos(), "bad.functional.intf.anno.1", ex.getDiagnostic());
 }
 }
 }
+}
+public void validateTypeAnnotation(JCAnnotation a, boolean isTypeParameter) {
+Assert.checkNonNull(a.type, "annotation tree hasn't been attributed yet: " + a);
+validateAnnotationTree(a);
+if (!isTypeAnnotation(a, isTypeParameter))
+log.error(a.pos(), "annotation.type.not.applicable");
 }
 /**
 * Validate the proposed container 'repeatable' on the
 * annotation type symbol 's'. Report errors at position
 }
 }
 return false;
 }
+/** Is the annotation applicable to type annotations? */
+protected boolean isTypeAnnotation(JCAnnotation a, boolean isTypeParameter) {
+Attribute.Compound atTarget =
+a.annotationType.type.tsym.attribute(syms.annotationTargetType.tsym);
+if (atTarget == null) {
+// An annotation without @Target is not a type annotation.
+return false;
+}
+Attribute atValue = atTarget.member(names.value);
+if (!(atValue instanceof Attribute.Array)) {
+return false; // error recovery
+}
+Attribute.Array arr = (Attribute.Array) atValue;
+for (Attribute app : arr.values) {
+if (!(app instanceof Attribute.Enum)) {
+return false; // recovery
+}
+Attribute.Enum e = (Attribute.Enum) app;
+if (e.value.name == names.TYPE_USE)
+return true;
+else if (isTypeParameter && e.value.name == names.TYPE_PARAMETER)
+return true;
+}
+return false;
+}
 /** Is the annotation applicable to the symbol? */
 boolean annotationApplicable(JCAnnotation a, Symbol s) {
 Attribute.Array arr = getAttributeTargetAttribute(a.annotationType.type.tsym);
+Name[] targets;
 if (arr == null) {
-return true;
+targets = defaultTargetMetaInfo(a, s);
-}
+} else {
-for (Attribute app : arr.values) {
+// TODO: can we optimize this?
-if (!(app instanceof Attribute.Enum)) return true; // recovery
+targets = new Name[arr.values.length];
-Attribute.Enum e = (Attribute.Enum) app;
+for (int i=0; i<arr.values.length; ++i) {
-if (e.value.name == names.TYPE)
+Attribute app = arr.values[i];
+if (!(app instanceof Attribute.Enum)) {
+return true; // recovery
+}
+Attribute.Enum e = (Attribute.Enum) app;
+targets[i] = e.value.name;
+}
+}
+for (Name target : targets) {
+if (target == names.TYPE)
 { if (s.kind == TYP) return true; }
-else if (e.value.name == names.FIELD)
+else if (target == names.FIELD)
 { if (s.kind == VAR && s.owner.kind != MTH) return true; }
-else if (e.value.name == names.METHOD)
+else if (target == names.METHOD)
 { if (s.kind == MTH && !s.isConstructor()) return true; }
-else if (e.value.name == names.PARAMETER)
+else if (target == names.PARAMETER)
 { if (s.kind == VAR &&
 s.owner.kind == MTH &&
 (s.flags() & PARAMETER) != 0)
 return true;
 }
-else if (e.value.name == names.CONSTRUCTOR)
+else if (target == names.CONSTRUCTOR)
 { if (s.kind == MTH && s.isConstructor()) return true; }
-else if (e.value.name == names.LOCAL_VARIABLE)
+else if (target == names.LOCAL_VARIABLE)
 { if (s.kind == VAR && s.owner.kind == MTH &&
 (s.flags() & PARAMETER) == 0)
 return true;
 }
-else if (e.value.name == names.ANNOTATION_TYPE)
+else if (target == names.ANNOTATION_TYPE)
 { if (s.kind == TYP && (s.flags() & ANNOTATION) != 0)
 return true;
 }
-else if (e.value.name == names.PACKAGE)
+else if (target == names.PACKAGE)
 { if (s.kind == PCK) return true; }
-else if (e.value.name == names.TYPE_USE)
+else if (target == names.TYPE_USE)
 { if (s.kind == TYP ||
 s.kind == VAR ||
 (s.kind == MTH && !s.isConstructor() &&
-!s.type.getReturnType().hasTag(VOID)))
+!s.type.getReturnType().hasTag(VOID)) ||
+(s.kind == MTH && s.isConstructor()))
+return true;
+}
+else if (target == names.TYPE_PARAMETER)
+{ if (s.kind == TYP && s.type.hasTag(TYPEVAR))
 return true;
 }
 else
 return true; // recovery
 }
 s.attribute(syms.annotationTargetType.tsym);
 if (atTarget == null) return null; // ok, is applicable
 Attribute atValue = atTarget.member(names.value);
 if (!(atValue instanceof Attribute.Array)) return null; // error recovery
 return (Attribute.Array) atValue;
+}
+private final Name[] dfltTargetMeta;
+private Name[] defaultTargetMetaInfo(JCAnnotation a, Symbol s) {
+return dfltTargetMeta;
 }
 /** Check an annotation value.
 *
 * @param a The annotation tree to check

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